package com.wicket.okrbff.biz.service.impl;


import com.wicket.okrapp.integration.FwAppOffStateClient;
import com.wicket.okrapp.integration.dto.*;
import com.wicket.okrbff.biz.service.OffStateService;
import com.wicket.okrbff.biz.service.dto.common.*;
import com.wicket.okrbff.biz.service.dto.req.*;
import com.wicket.okrbff.biz.service.dto.res.*;
import com.wicket.okrbff.common.util.RedisUtil;
import com.wicket.okrcomponent.integration.FwCompOffStateClient;
import com.wicket.okrcomponent.integration.dto.*;
import com.wicket.okrframework.integration.FwBaseAppSceneClient;
import com.wicket.okrframework.integration.FwBaseInductionRecordClient;
import com.wicket.okrframework.integration.FwBaseOffStateClient;
import com.wicket.okrframework.integration.dto.*;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.stream.Collectors;
import com.wicket.okrbff.common.exception.Assert;
import cn.hutool.core.bean.BeanUtil;

import java.util.ArrayList;
import java.util.List;
import com.wicket.okrapp.integration.FwAppTargetCycleClient;
import cn.hutool.core.collection.CollectionUtil;
import com.wicket.okrapp.integration.FwAppTargetContentClient;
import com.wicket.okrbff.common.util.CommonFunctionHelper;
import com.wicket.okrapp.integration.FwAppEvaSystemClient;
import com.wicket.okrcomponent.integration.FwCompTemplateEngineClient;
import com.wicket.okrapp.integration.FwAppInterfaceModeClient;
import com.wicket.okrapp.integration.FwAppExecuteProgressClient;
import com.wicket.okrcomponent.integration.FwCompInterfaceModeClient;
import com.wicket.okrbff.common.exception.BizException;

/**
 * @author ：
 * @date ：
 *
 *
 * @version 1.0
 */
@Service
public class OffStateServiceImpl implements OffStateService {
    @Resource
    FwAppOffStateClient fwAppOffStateClient;
    @Resource
    FwBaseAppSceneClient fwBaseAppSceneClient;
    @Resource
    FwBaseInductionRecordClient fwBaseInductionRecordClient;
    @Resource
    FwBaseOffStateClient fwBaseOffStateClient;
    @Resource
    FwCompOffStateClient fwCompOffStateClient;
    @Resource
    private RedisUtil redisUtil;
@Resource
  FwAppTargetCycleClient fwAppTargetCycleClient;
@Resource
  FwAppTargetContentClient fwAppTargetContentClient;
@Resource
  FwAppEvaSystemClient fwAppEvaSystemClient;
@Resource
  FwCompTemplateEngineClient fwCompTemplateEngineClient;

@Resource
  FwAppInterfaceModeClient fwAppInterfaceModeClient;
@Resource
  FwAppExecuteProgressClient fwAppExecuteProgressClient;
@Resource
  FwCompInterfaceModeClient fwCompInterfaceModeClient;






    /**
     * B1-1查询状态校验项列表（公共）
     */
    @Trace(operationName = "B1-1查询状态校验项列表（公共）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffQueryCheckItemStatListComRespDto queryCheckItemStatListCom(BffQueryCheckItemStatListComReqDto reqDto) {

        // 步骤0: D1-1查询状态校验项列表 - queryCheckItemStatList
        QueryCheckItemStatListRespDto queryCheckItemStatListRespDto = null;
        QueryCheckItemStatListReqDto queryCheckItemStatListReqDto = new QueryCheckItemStatListReqDto();
        if (reqDto != null) {
            queryCheckItemStatListReqDto.setCheckItemCode(reqDto.getCheckItemCode());// sourceId:19709_1
            queryCheckItemStatListReqDto.setObjectTypeCode(reqDto.getObjectTypeCode());// sourceId:19710_1
            queryCheckItemStatListReqDto.setEntityId(reqDto.getEntityId());// sourceId:19711_1
        }

        /* D1-1查询状态校验项列表[960] */
        queryCheckItemStatListRespDto = fwBaseOffStateClient.queryCheckItemStatList(queryCheckItemStatListReqDto)
                .getData();

        // 步骤1: D3-11查列表检查项 - queryCheckItemList
        QueryCheckItemListRespDto queryCheckItemListRespDto = null;
        QueryCheckItemListReqDto queryCheckItemListReqDto = new QueryCheckItemListReqDto();
        queryCheckItemListReqDto.setBizSceneCode("ORG_CHECK_ITEM");// CUSTOM_CONVENTION//sourceId:43038_1
        queryCheckItemListReqDto.setSubjectLifeCycle("CURRENTLY_VALID");// sourceId:43039_1

        /* D3-11查列表检查项[888] */
        queryCheckItemListRespDto = fwAppOffStateClient.queryCheckItemList(queryCheckItemListReqDto).getData();

        BffQueryCheckItemStatListComRespDto retData = new BffQueryCheckItemStatListComRespDto();
        // todo
        // master集合数量为0,请联系业务设计人员检查,是否设置了master集合?;关联关系如下:retData.getCheckItemStatList().setStatusCheckItemId(queryCheckItemStatListRespDto.getCheckItemStatList().getStatusCheckItemId());retData.getCheckItemStatList().setCheckItemCode(queryCheckItemStatListRespDto.getCheckItemStatList().getCheckItemCode());retData.getCheckItemStatList().setCheckItemName(queryCheckItemListRespDto.getCheckItemList().getCheckItemName());retData.getCheckItemStatList().setIsComplete(queryCheckItemStatListRespDto.getCheckItemStatList().getIsComplete())

        return retData;
    }

    /**
   * B1-1查询状态校验项详情（公共）[955]
   * gen by moon at 8/10/2022, 3:31:28 AM
   */
    @Trace(operationName = "B1-1查询状态校验项详情（公共）")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffQueryCheckItemStatDetailComRespDto queryCheckItemStatDetailCom(BffQueryCheckItemStatDetailComReqDto reqDto){
      
       
       QueryCheckItemStatDetailRespDto queryCheckItemStatDetailRespDto_1 = null;
//步骤0: D1-1查询状态校验项详情 - queryCheckItemStatDetail
     QueryCheckItemStatDetailRespDto queryCheckItemStatDetailRespDto = null;
    QueryCheckItemStatDetailReqDto queryCheckItemStatDetailReqDto=new QueryCheckItemStatDetailReqDto();
  if(reqDto!=null){
      queryCheckItemStatDetailReqDto.setCheckItemCode(reqDto.getCheckItemCode());//sourceId:19332_1
queryCheckItemStatDetailReqDto.setObjectTypeCode(reqDto.getObjectTypeCode());//sourceId:19333_1
queryCheckItemStatDetailReqDto.setEntityId(reqDto.getEntityId());//sourceId:19334_1
    }
  
    /*D1-1查询状态校验项详情[954]   */
    
      queryCheckItemStatDetailRespDto = fwBaseOffStateClient.queryCheckItemStatDetail(queryCheckItemStatDetailReqDto).getData();
      
      queryCheckItemStatDetailRespDto_1 = queryCheckItemStatDetailRespDto;
    
BffQueryCheckItemStatDetailComRespDto retData = new BffQueryCheckItemStatDetailComRespDto();
  if(queryCheckItemStatDetailRespDto_1!=null){
      retData.setIsComplete(queryCheckItemStatDetailRespDto_1.getIsComplete());//sourceId:19342_1
    }
  

  
  
return retData;
  }

    /**
   * B1-1修改状态校验项(（公共）[952]
   * gen by moon at 8/10/2022, 3:31:24 AM
   */
    @Trace(operationName = "B1-1修改状态校验项(（公共）")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffUpdateCheckItemStatComRespDto updateCheckItemStatCom(BffUpdateCheckItemStatComReqDto reqDto){
      
       
       //步骤0: D1-1修改检查项状态(公共) - updateCheckItemStatCom
     UpdateCheckItemStatComRespDto updateCheckItemStatComRespDto = null;
    UpdateCheckItemStatComReqDto updateCheckItemStatComReqDto=new UpdateCheckItemStatComReqDto();
  if(reqDto!=null){
      updateCheckItemStatComReqDto.setCheckItemCode(reqDto.getCheckItemCode());//sourceId:143264_1
updateCheckItemStatComReqDto.setObjectTypeCode(reqDto.getObjectTypeCode());//sourceId:143265_1
updateCheckItemStatComReqDto.setEntityId(reqDto.getEntityId());//sourceId:143266_1
updateCheckItemStatComReqDto.setIsComplete(reqDto.getIsComplete());//sourceId:19232_1
    }
  
    /*D1-1修改检查项状态(公共)[947]   */
    Assert.isNull(updateCheckItemStatComReqDto.getCheckItemCode(),"B1-1修改状态校验项(（公共）-D1-1修改检查项状态(公共)-检查项标识不能为空",false);
Assert.isNull(updateCheckItemStatComReqDto.getObjectTypeCode(),"B1-1修改状态校验项(（公共）-D1-1修改检查项状态(公共)-内容对象类型编码不能为空",false);
Assert.isNull(updateCheckItemStatComReqDto.getEntityId(),"B1-1修改状态校验项(（公共）-D1-1修改检查项状态(公共)-内容对象实例ID不能为空",false);
Assert.isNull(updateCheckItemStatComReqDto.getIsComplete(),"B1-1修改状态校验项(（公共）-D1-1修改检查项状态(公共)-是否已完成不能为空",false);
      updateCheckItemStatComRespDto = fwBaseOffStateClient.updateCheckItemStatCom(updateCheckItemStatComReqDto).getData();
      
      
    
BffUpdateCheckItemStatComRespDto retData = new BffUpdateCheckItemStatComRespDto();
  
  

  
  
return retData;
  }
/**
   * B1-1更新组织成员管理检查项等(管理)(公共)[952]
   * gen by moon at 8/26/2022, 7:31:59 PM
   */
    @Trace(operationName = "B1-1更新组织成员管理检查项等(管理)(公共)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffRefreshOrgMemberMgtCheckEtcComRespDto refreshOrgMemberMgtCheckEtcCom(BffRefreshOrgMemberMgtCheckEtcComReqDto reqDto){
      
       
       //步骤0: D1-3更新组织成员管理检查项等 - refreshOrgMemberMgtCheckEtc
     RefreshOrgMemberMgtCheckEtcRespDto refreshOrgMemberMgtCheckEtcRespDto = null;
    RefreshOrgMemberMgtCheckEtcReqDto refreshOrgMemberMgtCheckEtcReqDto=new RefreshOrgMemberMgtCheckEtcReqDto();
  if(reqDto!=null){
      refreshOrgMemberMgtCheckEtcReqDto.setOrganizationId(reqDto.getOrganizationId());//sourceId:257133_1
refreshOrgMemberMgtCheckEtcReqDto.setIsComplete(reqDto.getIsComplete());//sourceId:257134_1
    }
  
    /*D1-3更新组织成员管理检查项等[4184]   */
    Assert.isNull(refreshOrgMemberMgtCheckEtcReqDto.getOrganizationId(),"B1-1更新组织成员管理检查项等(管理)(公共)-D1-3更新组织成员管理检查项等-组织ID不能为空",false);
Assert.isNull(refreshOrgMemberMgtCheckEtcReqDto.getIsComplete(),"B1-1更新组织成员管理检查项等(管理)(公共)-D1-3更新组织成员管理检查项等-是否已完成不能为空",false);
      refreshOrgMemberMgtCheckEtcRespDto = fwBaseOffStateClient.refreshOrgMemberMgtCheckEtc(refreshOrgMemberMgtCheckEtcReqDto).getData();
      
      
    
BffRefreshOrgMemberMgtCheckEtcComRespDto retData = new BffRefreshOrgMemberMgtCheckEtcComRespDto();
  
  

  
  
return retData;
  }
/**
   * B3-11批量增目标校验项状态(管理)[3126]
   * gen by moon at 10/7/2022, 2:13:53 AM
   */
    @Trace(operationName = "B3-11批量增目标校验项状态(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffBatchAddTargetCheckItemStatRespDto batchAddTargetCheckItemStat(BffBatchAddTargetCheckItemStatReqDto reqDto){
      
       
       //步骤0: D3-11新增业务应用校验项状态(公共) - addBizAppCheckItemStatCom
     AddBizAppCheckItemStatComRespDto addBizAppCheckItemStatComRespDto = null;
    AddBizAppCheckItemStatComReqDto addBizAppCheckItemStatComReqDto=new AddBizAppCheckItemStatComReqDto();
  if(reqDto!=null){
      addBizAppCheckItemStatComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:367770_1
addBizAppCheckItemStatComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:367771_1
    }
  
    /*D3-11新增业务应用校验项状态(公共)[3120]   */
    Assert.isNull(addBizAppCheckItemStatComReqDto.getTargetId(),"B3-11批量增目标校验项状态(管理)-D3-11新增业务应用校验项状态(公共)-目标ID不能为空",false);
Assert.isNull(addBizAppCheckItemStatComReqDto.getEvaluationTemplateId(),"B3-11批量增目标校验项状态(管理)-D3-11新增业务应用校验项状态(公共)-冗余评价模板ID不能为空",false);
      addBizAppCheckItemStatComRespDto = fwAppOffStateClient.addBizAppCheckItemStatCom(addBizAppCheckItemStatComReqDto).getData();
      
      
      
    
BffBatchAddTargetCheckItemStatRespDto retData = new BffBatchAddTargetCheckItemStatRespDto();
  
  

  
  
return retData;
  }
/**
   * B3-13新增高层当前步骤(管理)[3127]
   * gen by moon at 8/29/2022, 1:21:51 AM
   */
    @Trace(operationName = "B3-13新增高层当前步骤(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffAddTopCurrentBstepRespDto addTopCurrentBstep(BffAddTopCurrentBstepReqDto reqDto){
      
       
       AddBizAppServiceContCurrentBstepComRespDto addBizAppServiceContCurrentBstepComRespDto_1 =null;
//步骤0: D3-11新增业务服务内容当前步骤(公共) - addBizAppServiceContCurrentBstepCom
     AddBizAppServiceContCurrentBstepComRespDto addBizAppServiceContCurrentBstepComRespDto = null;
    AddBizAppServiceContCurrentBstepComReqDto addBizAppServiceContCurrentBstepComReqDto=new AddBizAppServiceContCurrentBstepComReqDto();
  addBizAppServiceContCurrentBstepComReqDto.setStepObj("OMS_EVALUATION_TEMPLATE");//sourceId:108879_1
addBizAppServiceContCurrentBstepComReqDto.setBizSceneCode("TOP_PLAN_PREP");//CUSTOM_CONVENTION//sourceId:108882_1
addBizAppServiceContCurrentBstepComReqDto.setOrderNumber(1L);//CUSTOM_CONVENTION//sourceId:108883_1
if(reqDto!=null){
      addBizAppServiceContCurrentBstepComReqDto.setEntityId(reqDto.getEntityId());//sourceId:108880_1
    }
  
    /*D3-11新增业务服务内容当前步骤(公共)[2428]   */
    Assert.isNull(addBizAppServiceContCurrentBstepComReqDto.getEntityId(),"B3-13新增高层当前步骤(管理)-D3-11新增业务服务内容当前步骤(公共)-步骤内容实例ID不能为空",false);
Assert.isNull(addBizAppServiceContCurrentBstepComReqDto.getStepObj(),"B3-13新增高层当前步骤(管理)-D3-11新增业务服务内容当前步骤(公共)-步骤使用对象表不能为空",false);
Assert.isNull(addBizAppServiceContCurrentBstepComReqDto.getBizSceneCode(),"B3-13新增高层当前步骤(管理)-D3-11新增业务服务内容当前步骤(公共)-业务场景标识不能为空",false);
Assert.isNull(addBizAppServiceContCurrentBstepComReqDto.getOrderNumber(),"B3-13新增高层当前步骤(管理)-D3-11新增业务服务内容当前步骤(公共)-排序不能为空",false);
      addBizAppServiceContCurrentBstepComRespDto = fwAppOffStateClient.addBizAppServiceContCurrentBstepCom(addBizAppServiceContCurrentBstepComReqDto).getData();
      
      addBizAppServiceContCurrentBstepComRespDto_1 = addBizAppServiceContCurrentBstepComRespDto;
    
BffAddTopCurrentBstepRespDto retData = new BffAddTopCurrentBstepRespDto();
  if(addBizAppServiceContCurrentBstepComRespDto_1!=null){
      retData.setBehaviorCurrentStepId(addBizAppServiceContCurrentBstepComRespDto_1.getBehaviorCurrentStepId());//sourceId:108885_1
    }
  

  
  
return retData;
  }
/**
   * B3-11设完成高层切换第三步(管理)[2986]
   * gen by moon at 2/7/2024, 4:39:06 AM
   */
    @Trace(operationName = "B3-11设完成高层切换第三步(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffCompleteTopHandoverThreeStepRespDto completeTopHandoverThreeStep(BffCompleteTopHandoverThreeStepReqDto reqDto){
      
       
       ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto_1 =null;
//virtualUsage D2执行上并发高中基层步骤变更锁(公共)  61106
      ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto = null;
    ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto=new ImplementConcBhvThemeLockComComReqDto();
  implementConcBhvThemeLockComComReqDto.setPreventConcurrentLockingUnlocking("LOCK");//sourceId:1540059_1_61106
implementConcBhvThemeLockComComReqDto.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540060_1_61106
implementConcBhvThemeLockComComReqDto.setDuration(Long.valueOf(5));//CUSTOM_CONVENTION//sourceId:1540065_1_61106
implementConcBhvThemeLockComComReqDto.setTimeUnitType("MINUTES");//sourceId:1540066_1_61106
implementConcBhvThemeLockComComReqDto.setHandlingMethodConcurrentLockFailure("CONCURRENT_LOCK_FAILURE_ERROR_REPORTING");//sourceId:1540067_1_61106
if(reqDto!=null){
      implementConcBhvThemeLockComComReqDto.setCommPrimaryKey(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540061_1_61106
    }

    /*D2执行上并发高中基层步骤变更锁(公共)[8388]   */
    Assert.isNull(implementConcBhvThemeLockComComReqDto.getPreventConcurrentLockingUnlocking(),"B3-11设完成高层切换第三步(管理)-D2执行上并发高中基层步骤变更锁(公共)-防并发上锁or解锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getBehaviorThemeLockCode(),"B3-11设完成高层切换第三步(管理)-D2执行上并发高中基层步骤变更锁(公共)-行为主题锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getCommPrimaryKey(),"B3-11设完成高层切换第三步(管理)-D2执行上并发高中基层步骤变更锁(公共)-通用主键ID不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getDuration(),"B3-11设完成高层切换第三步(管理)-D2执行上并发高中基层步骤变更锁(公共)-锁定时长不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getTimeUnitType(),"B3-11设完成高层切换第三步(管理)-D2执行上并发高中基层步骤变更锁(公共)-时间单位类型不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getHandlingMethodConcurrentLockFailure(),"B3-11设完成高层切换第三步(管理)-D2执行上并发高中基层步骤变更锁(公共)-并发上锁失败处理方式不能为空",false);
      implementConcBhvThemeLockComComRespDto = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((implementConcBhvThemeLockComComRespDto!= null&&  implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() !=null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("EMPTY_LOCK_SUCCESSFUL"))) {
        //if(D2执行上并发高中基层步骤变更锁(公共).防并发上锁情况 等于 空上锁成功)  61107

      ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto = null;
    ImplementTopMidBasicGuideStepRoomReqDto implementTopMidBasicGuideStepRoomReqDto=new ImplementTopMidBasicGuideStepRoomReqDto();
  implementTopMidBasicGuideStepRoomReqDto.setDeptTargetWeightSet("1");//CUSTOM_CONVENTION//sourceId:1203498_1_61108
implementTopMidBasicGuideStepRoomReqDto.setBatchOperateScene("TOP");//sourceId:1203499_1_61108
if(reqDto!=null){
      implementTopMidBasicGuideStepRoomReqDto.setWeightSetWay(reqDto.getWeightSetWay());//SimpleFieldAssign//sourceId:1203500_1_61108
    }

    /*D3执行高中基层导向步骤房间[7600]   */
    Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getDeptTargetWeightSet(),"B3-11设完成高层切换第三步(管理)-D3执行高中基层导向步骤房间-部门目标权重设置不能为空",false);
Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getBatchOperateScene(),"B3-11设完成高层切换第三步(管理)-D3执行高中基层导向步骤房间-高/中/基层操作场景不能为空",false);
Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getWeightSetWay(),"B3-11设完成高层切换第三步(管理)-D3执行高中基层导向步骤房间-权重设置方式不能为空",false);
      implementTopMidBasicGuideStepRoomRespDto = fwAppEvaSystemClient.implementTopMidBasicGuideStepRoom(implementTopMidBasicGuideStepRoomReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      implementTopMidBasicGuideStepRoomRespDto_1 = implementTopMidBasicGuideStepRoomRespDto;
ImplementTopMidBasicCurrentBstepJudgeComRespDto implementTopMidBasicCurrentBstepJudgeComRespDto = null;
    if(implementTopMidBasicGuideStepRoomRespDto !=null){
          ImplementTopMidBasicCurrentBstepJudgeComReqDto implementTopMidBasicCurrentBstepJudgeComReqDto=new ImplementTopMidBasicCurrentBstepJudgeComReqDto();
  implementTopMidBasicCurrentBstepJudgeComReqDto.setBatchOperateScene("TOP");//sourceId:1540085_1_61109
if(reqDto!=null){
      implementTopMidBasicCurrentBstepJudgeComReqDto.setEntityId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540081_1_61109
implementTopMidBasicCurrentBstepJudgeComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540082_1_61109
    }
if(implementTopMidBasicGuideStepRoomRespDto!=null){
      implementTopMidBasicCurrentBstepJudgeComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:1540084_1_61109
    }

    /*D3执行高中基层当前步骤判断(公共)[7303]   */
    Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getEntityId(),"B3-11设完成高层切换第三步(管理)-D3执行高中基层当前步骤判断(公共)-步骤内容实例ID不能为空",false);
Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getStepRoomValue(),"B3-11设完成高层切换第三步(管理)-D3执行高中基层当前步骤判断(公共)-进入步骤房间值不能为空",false);
Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getThemeContentId(),"B3-11设完成高层切换第三步(管理)-D3执行高中基层当前步骤判断(公共)-主题内容ID不能为空",false);
Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getBatchOperateScene(),"B3-11设完成高层切换第三步(管理)-D3执行高中基层当前步骤判断(公共)-高/中/基层操作场景不能为空",false);
      implementTopMidBasicCurrentBstepJudgeComRespDto = fwAppOffStateClient.implementTopMidBasicCurrentBstepJudgeCom(implementTopMidBasicCurrentBstepJudgeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((implementTopMidBasicCurrentBstepJudgeComRespDto!= null&&  implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() !=null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("FALSE"))) {
        //if(D3执行高中基层当前步骤判断(公共).是否相等 等于 否)  61110

     CompleteTopHandoverThreeStepRespDto completeTopHandoverThreeStepRespDto = null;
    if(implementTopMidBasicGuideStepRoomRespDto !=null){
    CompleteTopHandoverThreeStepReqDto completeTopHandoverThreeStepReqDto=new CompleteTopHandoverThreeStepReqDto();
  if(reqDto!=null){
      completeTopHandoverThreeStepReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:849703_1_61111
completeTopHandoverThreeStepReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:849704_1_61111
    }
if(implementTopMidBasicGuideStepRoomRespDto!=null){
      completeTopHandoverThreeStepReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:1203478_1_61111
    }
  
    /*D3-11设完成高层切换第三步[3950]   */
    Assert.isNull(completeTopHandoverThreeStepReqDto.getTargetId(),"B3-11设完成高层切换第三步(管理)-D3-11设完成高层切换第三步-冗余目标ID不能为空",false);
    Assert.isNull(completeTopHandoverThreeStepReqDto.getEvaluationTemplateId(),"B3-11设完成高层切换第三步(管理)-D3-11设完成高层切换第三步-冗余评价模板ID不能为空",false);
Assert.isNull(completeTopHandoverThreeStepReqDto.getStepRoomValue(),"B3-11设完成高层切换第三步(管理)-D3-11设完成高层切换第三步-进入步骤房间值不能为空",false);
      completeTopHandoverThreeStepRespDto = fwAppOffStateClient.completeTopHandoverThreeStep(completeTopHandoverThreeStepReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      

    
           }
ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto_2 = null;
    ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto_1=new ImplementConcBhvThemeLockComComReqDto();
  implementConcBhvThemeLockComComReqDto_1.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1540070_1_61116
implementConcBhvThemeLockComComReqDto_1.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540071_1_61116
implementConcBhvThemeLockComComReqDto_1.setWhetherUnlockBulk("FALSE");//sourceId:1540079_1_61116
if(reqDto!=null){
      implementConcBhvThemeLockComComReqDto_1.setCommPrimaryKey(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540072_1_61116
    }

    /*D2执行并发行为主题解锁(公共)[8388]   */
    Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getPreventConcurrentLockingUnlocking(),"B3-11设完成高层切换第三步(管理)-D2执行并发行为主题解锁(公共)-防并发上锁or解锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getBehaviorThemeLockCode(),"B3-11设完成高层切换第三步(管理)-D2执行并发行为主题解锁(公共)-行为主题锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getCommPrimaryKey(),"B3-11设完成高层切换第三步(管理)-D2执行并发行为主题解锁(公共)-通用主键ID不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getWhetherUnlockBulk(),"B3-11设完成高层切换第三步(管理)-D2执行并发行为主题解锁(公共)-是否批量解锁不能为空",false);
      implementConcBhvThemeLockComComRespDto_2 = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



      }
else if((implementTopMidBasicCurrentBstepJudgeComRespDto!= null&&  implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() !=null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("TRUE"))){
       //elseif(D3执行高中基层当前步骤判断(公共).是否相等 等于 是)  61112

//异常结束 61113
      throw new BizException("B10100289","对不起！当前房间已变化，请刷新页面~",false);
    }
      }
else if((implementConcBhvThemeLockComComRespDto!= null&&  implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() !=null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("CONCURRENT_LOCK_FAILURE"))){
       //elseif(D2执行上并发高中基层步骤变更锁(公共).防并发上锁情况 等于 并发上锁失败)  61114

//异常结束 61115
      throw new BizException("B10100288","操作过于频繁，请稍后再试~",false);
      }
BffCompleteTopHandoverThreeStepRespDto retData = new BffCompleteTopHandoverThreeStepRespDto();
  if(implementTopMidBasicGuideStepRoomRespDto_1!=null){
      retData.setStepNameCode(implementTopMidBasicGuideStepRoomRespDto_1.getStepNameCode());//SimpleFieldAssign//sourceId:1203497_1
    }
  

  
  
return retData;
  }
/**
   * B3-11高层确认设置完成(管理)[2989]
   * gen by moon at 2/7/2024, 4:39:12 AM
   */
    @Trace(operationName = "B3-11高层确认设置完成(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffCompleteTopNotarizeSetAchieveRespDto completeTopNotarizeSetAchieve(BffCompleteTopNotarizeSetAchieveReqDto reqDto){
      
       
       ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto_1 =null;
//virtualUsage D2执行上并发高中基层步骤变更锁(公共)  61117
      ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto = null;
    ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto=new ImplementConcBhvThemeLockComComReqDto();
  implementConcBhvThemeLockComComReqDto.setPreventConcurrentLockingUnlocking("LOCK");//sourceId:1540086_1_61117
implementConcBhvThemeLockComComReqDto.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540087_1_61117
implementConcBhvThemeLockComComReqDto.setDuration(Long.valueOf(5));//CUSTOM_CONVENTION//sourceId:1540092_1_61117
implementConcBhvThemeLockComComReqDto.setTimeUnitType("MINUTES");//sourceId:1540093_1_61117
implementConcBhvThemeLockComComReqDto.setHandlingMethodConcurrentLockFailure("CONCURRENT_LOCK_FAILURE_NO_ERROR_REPORTED");//sourceId:1540094_1_61117
if(reqDto!=null){
      implementConcBhvThemeLockComComReqDto.setCommPrimaryKey(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540088_1_61117
    }

    /*D2执行上并发高中基层步骤变更锁(公共)[8388]   */
    Assert.isNull(implementConcBhvThemeLockComComReqDto.getPreventConcurrentLockingUnlocking(),"B3-11高层确认设置完成(管理)-D2执行上并发高中基层步骤变更锁(公共)-防并发上锁or解锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getBehaviorThemeLockCode(),"B3-11高层确认设置完成(管理)-D2执行上并发高中基层步骤变更锁(公共)-行为主题锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getCommPrimaryKey(),"B3-11高层确认设置完成(管理)-D2执行上并发高中基层步骤变更锁(公共)-通用主键ID不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getDuration(),"B3-11高层确认设置完成(管理)-D2执行上并发高中基层步骤变更锁(公共)-锁定时长不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getTimeUnitType(),"B3-11高层确认设置完成(管理)-D2执行上并发高中基层步骤变更锁(公共)-时间单位类型不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getHandlingMethodConcurrentLockFailure(),"B3-11高层确认设置完成(管理)-D2执行上并发高中基层步骤变更锁(公共)-并发上锁失败处理方式不能为空",false);
      implementConcBhvThemeLockComComRespDto = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((implementConcBhvThemeLockComComRespDto!= null&&  implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() !=null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("EMPTY_LOCK_SUCCESSFUL"))) {
        //if(D2执行上并发高中基层步骤变更锁(公共).防并发上锁情况 等于 空上锁成功)  61118

      ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto = null;
    ImplementTopMidBasicGuideStepRoomReqDto implementTopMidBasicGuideStepRoomReqDto=new ImplementTopMidBasicGuideStepRoomReqDto();
  implementTopMidBasicGuideStepRoomReqDto.setBatchOperateScene("TOP");//sourceId:1203520_1_61119
implementTopMidBasicGuideStepRoomReqDto.setPlanStaffingAchieve("1");//CUSTOM_CONVENTION//sourceId:1203447_1_61119
if(reqDto!=null){
      implementTopMidBasicGuideStepRoomReqDto.setWeightSetWay(reqDto.getWeightSetWay());//SimpleFieldAssign//sourceId:1203445_1_61119
    }

    /*D3执行高中基层导向步骤房间[7600]   */
    Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getBatchOperateScene(),"B3-11高层确认设置完成(管理)-D3执行高中基层导向步骤房间-高/中/基层操作场景不能为空",false);
Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getPlanStaffingAchieve(),"B3-11高层确认设置完成(管理)-D3执行高中基层导向步骤房间-规划编制完成不能为空",false);
Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getWeightSetWay(),"B3-11高层确认设置完成(管理)-D3执行高中基层导向步骤房间-权重设置方式不能为空",false);
      implementTopMidBasicGuideStepRoomRespDto = fwAppEvaSystemClient.implementTopMidBasicGuideStepRoom(implementTopMidBasicGuideStepRoomReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      implementTopMidBasicGuideStepRoomRespDto_1 = implementTopMidBasicGuideStepRoomRespDto;
ImplementTopMidBasicCurrentBstepJudgeComRespDto implementTopMidBasicCurrentBstepJudgeComRespDto = null;
    if(implementTopMidBasicGuideStepRoomRespDto !=null){
          ImplementTopMidBasicCurrentBstepJudgeComReqDto implementTopMidBasicCurrentBstepJudgeComReqDto=new ImplementTopMidBasicCurrentBstepJudgeComReqDto();
  implementTopMidBasicCurrentBstepJudgeComReqDto.setBatchOperateScene("TOP");//sourceId:1540112_1_61120
if(reqDto!=null){
      implementTopMidBasicCurrentBstepJudgeComReqDto.setEntityId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540108_1_61120
implementTopMidBasicCurrentBstepJudgeComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540109_1_61120
    }
if(implementTopMidBasicGuideStepRoomRespDto!=null){
      implementTopMidBasicCurrentBstepJudgeComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:1540111_1_61120
    }

    /*D3执行高中基层当前步骤判断(公共)[7303]   */
    Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getEntityId(),"B3-11高层确认设置完成(管理)-D3执行高中基层当前步骤判断(公共)-步骤内容实例ID不能为空",false);
Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getStepRoomValue(),"B3-11高层确认设置完成(管理)-D3执行高中基层当前步骤判断(公共)-进入步骤房间值不能为空",false);
Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getThemeContentId(),"B3-11高层确认设置完成(管理)-D3执行高中基层当前步骤判断(公共)-主题内容ID不能为空",false);
Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getBatchOperateScene(),"B3-11高层确认设置完成(管理)-D3执行高中基层当前步骤判断(公共)-高/中/基层操作场景不能为空",false);
      implementTopMidBasicCurrentBstepJudgeComRespDto = fwAppOffStateClient.implementTopMidBasicCurrentBstepJudgeCom(implementTopMidBasicCurrentBstepJudgeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((implementTopMidBasicCurrentBstepJudgeComRespDto!= null&&  implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() !=null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("FALSE"))) {
        //if(D3执行高中基层当前步骤判断(公共).是否相等 等于 否)  61121

     CompleteTopNotarizeSetAchieveRespDto completeTopNotarizeSetAchieveRespDto = null;
    if(implementTopMidBasicGuideStepRoomRespDto !=null){
    CompleteTopNotarizeSetAchieveReqDto completeTopNotarizeSetAchieveReqDto=new CompleteTopNotarizeSetAchieveReqDto();
  if(reqDto!=null){
      completeTopNotarizeSetAchieveReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:206993_1_61122
completeTopNotarizeSetAchieveReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:206994_1_61122
    }
if(implementTopMidBasicGuideStepRoomRespDto!=null){
      completeTopNotarizeSetAchieveReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:1203443_1_61122
    }
  
    /*D3-11设完成高层确认设置完成[3952]   */
    Assert.isNull(completeTopNotarizeSetAchieveReqDto.getTargetId(),"B3-11高层确认设置完成(管理)-D3-11设完成高层确认设置完成-冗余目标ID不能为空",false);
Assert.isNull(completeTopNotarizeSetAchieveReqDto.getEvaluationTemplateId(),"B3-11高层确认设置完成(管理)-D3-11设完成高层确认设置完成-冗余评价模板ID不能为空",false);
Assert.isNull(completeTopNotarizeSetAchieveReqDto.getStepRoomValue(),"B3-11高层确认设置完成(管理)-D3-11设完成高层确认设置完成-进入步骤房间值不能为空",false);
      completeTopNotarizeSetAchieveRespDto = fwAppOffStateClient.completeTopNotarizeSetAchieve(completeTopNotarizeSetAchieveReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      

    
           }
ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto_2 = null;
    ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto_1=new ImplementConcBhvThemeLockComComReqDto();
  implementConcBhvThemeLockComComReqDto_1.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1540113_1_61123
implementConcBhvThemeLockComComReqDto_1.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540114_1_61123
implementConcBhvThemeLockComComReqDto_1.setWhetherUnlockBulk("FALSE");//sourceId:1540116_1_61123
if(reqDto!=null){
      implementConcBhvThemeLockComComReqDto_1.setCommPrimaryKey(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540115_1_61123
    }

    /*D2-执行并发行为主题解锁(公共)[8388]   */
    Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getPreventConcurrentLockingUnlocking(),"B3-11高层确认设置完成(管理)-D2-执行并发行为主题解锁(公共)-防并发上锁or解锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getBehaviorThemeLockCode(),"B3-11高层确认设置完成(管理)-D2-执行并发行为主题解锁(公共)-行为主题锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getCommPrimaryKey(),"B3-11高层确认设置完成(管理)-D2-执行并发行为主题解锁(公共)-通用主键ID不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getWhetherUnlockBulk(),"B3-11高层确认设置完成(管理)-D2-执行并发行为主题解锁(公共)-是否批量解锁不能为空",false);
      implementConcBhvThemeLockComComRespDto_2 = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



      }
else if((implementTopMidBasicCurrentBstepJudgeComRespDto!= null&&  implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() !=null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("TRUE"))){
       //elseif(D3执行高中基层当前步骤判断(公共).是否相等 等于 是)  61124

//异常结束 61125
      throw new BizException("B10100289","对不起！当前房间已变化，请刷新页面~",false);
    }
      }
else if((implementConcBhvThemeLockComComRespDto!= null&&  implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() !=null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("CONCURRENT_LOCK_FAILURE"))){
       //elseif(D2执行上并发高中基层步骤变更锁(公共).防并发上锁情况 等于 并发上锁失败)  61126

//异常结束 61127
      throw new BizException("B10100288","操作过于频繁，请稍后再试~",false);
      }
BffCompleteTopNotarizeSetAchieveRespDto retData = new BffCompleteTopNotarizeSetAchieveRespDto();
  if(implementTopMidBasicGuideStepRoomRespDto_1!=null){
      retData.setStepNameCode(implementTopMidBasicGuideStepRoomRespDto_1.getStepNameCode());//SimpleFieldAssign//sourceId:1203477_1
    }
  

  
  
return retData;
  }
/**
   * B3-11高层重新编辑(管理)[2992]
   * gen by moon at 2/7/2024, 4:39:16 AM
   */
    @Trace(operationName = "B3-11高层重新编辑(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffUpdateTopEditRespDto updateTopEdit(BffUpdateTopEditReqDto reqDto){
      
       
       ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto_1 =null;
//virtualUsage D2执行上并发高中基层步骤变更锁(公共)  61128
      ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto = null;
    ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto=new ImplementConcBhvThemeLockComComReqDto();
  implementConcBhvThemeLockComComReqDto.setPreventConcurrentLockingUnlocking("LOCK");//sourceId:1540117_1_61128
implementConcBhvThemeLockComComReqDto.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540118_1_61128
implementConcBhvThemeLockComComReqDto.setDuration(Long.valueOf(5));//CUSTOM_CONVENTION//sourceId:1540123_1_61128
implementConcBhvThemeLockComComReqDto.setTimeUnitType("MINUTES");//sourceId:1540124_1_61128
implementConcBhvThemeLockComComReqDto.setHandlingMethodConcurrentLockFailure("CONCURRENT_LOCK_FAILURE_NO_ERROR_REPORTED");//sourceId:1540125_1_61128
if(reqDto!=null){
      implementConcBhvThemeLockComComReqDto.setCommPrimaryKey(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540119_1_61128
    }

    /*D2执行上并发高中基层步骤变更锁(公共)[8388]   */
    Assert.isNull(implementConcBhvThemeLockComComReqDto.getPreventConcurrentLockingUnlocking(),"B3-11高层重新编辑(管理)-D2执行上并发高中基层步骤变更锁(公共)-防并发上锁or解锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getBehaviorThemeLockCode(),"B3-11高层重新编辑(管理)-D2执行上并发高中基层步骤变更锁(公共)-行为主题锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getCommPrimaryKey(),"B3-11高层重新编辑(管理)-D2执行上并发高中基层步骤变更锁(公共)-通用主键ID不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getDuration(),"B3-11高层重新编辑(管理)-D2执行上并发高中基层步骤变更锁(公共)-锁定时长不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getTimeUnitType(),"B3-11高层重新编辑(管理)-D2执行上并发高中基层步骤变更锁(公共)-时间单位类型不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getHandlingMethodConcurrentLockFailure(),"B3-11高层重新编辑(管理)-D2执行上并发高中基层步骤变更锁(公共)-并发上锁失败处理方式不能为空",false);
      implementConcBhvThemeLockComComRespDto = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((implementConcBhvThemeLockComComRespDto!= null&&  implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() !=null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("EMPTY_LOCK_SUCCESSFUL"))) {
        //if(D2执行上并发高中基层步骤变更锁(公共).防并发上锁情况 等于 空上锁成功)  61129

      ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto = null;
    ImplementTopMidBasicGuideStepRoomReqDto implementTopMidBasicGuideStepRoomReqDto=new ImplementTopMidBasicGuideStepRoomReqDto();
  implementTopMidBasicGuideStepRoomReqDto.setReedit("1");//CUSTOM_CONVENTION//sourceId:1203293_1_61130
implementTopMidBasicGuideStepRoomReqDto.setBatchOperateScene("TOP");//sourceId:1203286_1_61130
if(reqDto!=null){
      implementTopMidBasicGuideStepRoomReqDto.setWeightSetWay(reqDto.getWeightSetWay());//SimpleFieldAssign//sourceId:1203333_1_61130
    }

    /*D3执行高中基层导向步骤房间[7600]   */
    Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getReedit(),"B3-11高层重新编辑(管理)-D3执行高中基层导向步骤房间-重新编辑不能为空",false);
Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getBatchOperateScene(),"B3-11高层重新编辑(管理)-D3执行高中基层导向步骤房间-高/中/基层操作场景不能为空",false);
Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getWeightSetWay(),"B3-11高层重新编辑(管理)-D3执行高中基层导向步骤房间-权重设置方式不能为空",false);
      implementTopMidBasicGuideStepRoomRespDto = fwAppEvaSystemClient.implementTopMidBasicGuideStepRoom(implementTopMidBasicGuideStepRoomReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      implementTopMidBasicGuideStepRoomRespDto_1 = implementTopMidBasicGuideStepRoomRespDto;
ImplementTopMidBasicCurrentBstepJudgeComRespDto implementTopMidBasicCurrentBstepJudgeComRespDto = null;
    if(implementTopMidBasicGuideStepRoomRespDto !=null){
          ImplementTopMidBasicCurrentBstepJudgeComReqDto implementTopMidBasicCurrentBstepJudgeComReqDto=new ImplementTopMidBasicCurrentBstepJudgeComReqDto();
  implementTopMidBasicCurrentBstepJudgeComReqDto.setBatchOperateScene("TOP");//sourceId:1540143_1_61131
if(reqDto!=null){
      implementTopMidBasicCurrentBstepJudgeComReqDto.setEntityId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540139_1_61131
implementTopMidBasicCurrentBstepJudgeComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540140_1_61131
    }
if(implementTopMidBasicGuideStepRoomRespDto!=null){
      implementTopMidBasicCurrentBstepJudgeComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:1540142_1_61131
    }

    /*D3执行高中基层当前步骤判断(公共)[7303]   */
    Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getEntityId(),"B3-11高层重新编辑(管理)-D3执行高中基层当前步骤判断(公共)-步骤内容实例ID不能为空",false);
Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getStepRoomValue(),"B3-11高层重新编辑(管理)-D3执行高中基层当前步骤判断(公共)-进入步骤房间值不能为空",false);
Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getThemeContentId(),"B3-11高层重新编辑(管理)-D3执行高中基层当前步骤判断(公共)-主题内容ID不能为空",false);
Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getBatchOperateScene(),"B3-11高层重新编辑(管理)-D3执行高中基层当前步骤判断(公共)-高/中/基层操作场景不能为空",false);
      implementTopMidBasicCurrentBstepJudgeComRespDto = fwAppOffStateClient.implementTopMidBasicCurrentBstepJudgeCom(implementTopMidBasicCurrentBstepJudgeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((implementTopMidBasicCurrentBstepJudgeComRespDto!= null&&  implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() !=null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("FALSE"))) {
        //if(D3执行高中基层当前步骤判断(公共).是否相等 等于 否)  61132

     CancelCompleteTopEditRespDto cancelCompleteTopEditRespDto = null;
    if(implementTopMidBasicGuideStepRoomRespDto !=null){
    CancelCompleteTopEditReqDto cancelCompleteTopEditReqDto=new CancelCompleteTopEditReqDto();
  if(reqDto!=null){
      cancelCompleteTopEditReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:862402_1_61133
cancelCompleteTopEditReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:323348_1_61133
cancelCompleteTopEditReqDto.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:856669_1_61133
cancelCompleteTopEditReqDto.setBatchCurrentStatus(reqDto.getBatchCurrentStatus());//SimpleFieldAssign//sourceId:856670_1_61133
    }
if(implementTopMidBasicGuideStepRoomRespDto!=null){
      cancelCompleteTopEditReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:849900_1_61133
    }
  
    /*D3-11高层重新编辑[4550]   */
    Assert.isNull(cancelCompleteTopEditReqDto.getTargetId(),"B3-11高层重新编辑(管理)-D3-11高层重新编辑-冗余目标ID不能为空",false);
Assert.isNull(cancelCompleteTopEditReqDto.getEvaluationTemplateId(),"B3-11高层重新编辑(管理)-D3-11高层重新编辑-冗余评价模板ID不能为空",false);
Assert.isNull(cancelCompleteTopEditReqDto.getStepRoomValue(),"B3-11高层重新编辑(管理)-D3-11高层重新编辑-进入步骤房间值不能为空",false);
Assert.isNull(cancelCompleteTopEditReqDto.getBatchCode(),"B3-11高层重新编辑(管理)-D3-11高层重新编辑-批次标识不能为空",false);
Assert.isNull(cancelCompleteTopEditReqDto.getBatchCurrentStatus(),"B3-11高层重新编辑(管理)-D3-11高层重新编辑-批次现状不能为空",false);
      cancelCompleteTopEditRespDto = fwAppOffStateClient.cancelCompleteTopEdit(cancelCompleteTopEditReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      

    
           }
ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto_2 = null;
    ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto_1=new ImplementConcBhvThemeLockComComReqDto();
  implementConcBhvThemeLockComComReqDto_1.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1540144_1_61134
implementConcBhvThemeLockComComReqDto_1.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540145_1_61134
implementConcBhvThemeLockComComReqDto_1.setWhetherUnlockBulk("FALSE");//sourceId:1540147_1_61134
if(reqDto!=null){
      implementConcBhvThemeLockComComReqDto_1.setCommPrimaryKey(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540146_1_61134
    }

    /*D2执行并发行为主题解锁(公共)[8388]   */
    Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getPreventConcurrentLockingUnlocking(),"B3-11高层重新编辑(管理)-D2执行并发行为主题解锁(公共)-防并发上锁or解锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getBehaviorThemeLockCode(),"B3-11高层重新编辑(管理)-D2执行并发行为主题解锁(公共)-行为主题锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getCommPrimaryKey(),"B3-11高层重新编辑(管理)-D2执行并发行为主题解锁(公共)-通用主键ID不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getWhetherUnlockBulk(),"B3-11高层重新编辑(管理)-D2执行并发行为主题解锁(公共)-是否批量解锁不能为空",false);
      implementConcBhvThemeLockComComRespDto_2 = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



      }
else if((implementTopMidBasicCurrentBstepJudgeComRespDto!= null&&  implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() !=null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("TRUE"))){
       //elseif(D3执行高中基层当前步骤判断(公共).是否相等 等于 是)  61135

//异常结束 61136
      throw new BizException("B10100289","对不起！当前房间已变化，请刷新页面~",false);
    }
      }
else if((implementConcBhvThemeLockComComRespDto!= null&&  implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() !=null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("CONCURRENT_LOCK_FAILURE"))){
       //elseif(D2执行上并发高中基层步骤变更锁(公共).防并发上锁情况 等于 并发上锁失败)  61137

//异常结束 61138
      throw new BizException("B10100288","操作过于频繁，请稍后再试~",false);
      }
BffUpdateTopEditRespDto retData = new BffUpdateTopEditRespDto();
  if(implementTopMidBasicGuideStepRoomRespDto_1!=null){
      retData.setStepNameCode(implementTopMidBasicGuideStepRoomRespDto_1.getStepNameCode());//SimpleFieldAssign//sourceId:1203338_1
    }
  

  
  
return retData;
  }
/**
   * B3-11查高层编制目标任务校验项状态列表(管理)[3009]
   * gen by moon at 10/8/2022, 3:09:48 AM
   */
    @Trace(operationName = "B3-11查高层编制目标任务校验项状态列表(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffQueryTopCompileTargetTaskcheckItemStatListRespDto queryTopCompileTargetTaskcheckItemStatList(BffQueryTopCompileTargetTaskcheckItemStatListReqDto reqDto){
      
       
       QueryTopCompileTargetTaskcheckItemStatListRespDto queryTopCompileTargetTaskcheckItemStatListRespDto_1 =null;
//步骤0: D3-11查询高层编制目标任务校验项状态列表 - queryTopCompileTargetTaskcheckItemStatList
     QueryTopCompileTargetTaskcheckItemStatListRespDto queryTopCompileTargetTaskcheckItemStatListRespDto = null;
    QueryTopCompileTargetTaskcheckItemStatListReqDto queryTopCompileTargetTaskcheckItemStatListReqDto=new QueryTopCompileTargetTaskcheckItemStatListReqDto();
  if(reqDto!=null){
      queryTopCompileTargetTaskcheckItemStatListReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:322839_1
    }
  
    /*D3-11查询高层编制目标任务校验项状态列表[3010]   */
    Assert.isNull(queryTopCompileTargetTaskcheckItemStatListReqDto.getEntityId(),"B3-11查高层编制目标任务校验项状态列表(管理)-D3-11查询高层编制目标任务校验项状态列表-目标ID不能为空",false);
      queryTopCompileTargetTaskcheckItemStatListRespDto = fwAppOffStateClient.queryTopCompileTargetTaskcheckItemStatList(queryTopCompileTargetTaskcheckItemStatListReqDto).getData();
      
      
      queryTopCompileTargetTaskcheckItemStatListRespDto_1 = queryTopCompileTargetTaskcheckItemStatListRespDto;
    
BffQueryTopCompileTargetTaskcheckItemStatListRespDto retData = new BffQueryTopCompileTargetTaskcheckItemStatListRespDto();
  if(queryTopCompileTargetTaskcheckItemStatListRespDto_1!=null){
      retData.setBizAppCheckItemStatList(queryTopCompileTargetTaskcheckItemStatListRespDto_1.getBizAppCheckItemStatList().stream().map(item -> BeanUtil.toBean(item, BffBizAppCheckItemStatDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:322840_1
retData.setCalcCount(queryTopCompileTargetTaskcheckItemStatListRespDto_1.getCalcCount());//SimpleFieldAssign//sourceId:306199_1
retData.setAlreadyAccomplishNum(queryTopCompileTargetTaskcheckItemStatListRespDto_1.getAlreadyAccomplishNum());//SimpleFieldAssign//sourceId:306200_1
    }
  

  
  
return retData;
  }
/**
   * B2-9查步骤列表(边界)[3055]
   * gen by moon at 10/24/2022, 4:31:54 AM
   */
    @Trace(operationName = "B2-9查步骤列表(边界)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffQueryStepListBorderRespDto queryStepListBorder(BffQueryStepListBorderReqDto reqDto){
      
       
       JudgeTopMidBasicStepRespDto judgeTopMidBasicStepRespDto_1 =null;
//步骤0: D3-9判断高中基层步骤 - judgeTopMidBasicStep
     JudgeTopMidBasicStepRespDto judgeTopMidBasicStepRespDto = null;
    JudgeTopMidBasicStepReqDto judgeTopMidBasicStepReqDto=new JudgeTopMidBasicStepReqDto();
  if(reqDto!=null){
      judgeTopMidBasicStepReqDto.setBatchOperateScene(reqDto.getBatchOperateScene());//SimpleFieldAssign//sourceId:388494_1
judgeTopMidBasicStepReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:370627_1
judgeTopMidBasicStepReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:370628_1
    }
  
    /*D3-9判断高中基层步骤[4787]   */
    Assert.isNull(judgeTopMidBasicStepReqDto.getBatchOperateScene(),"B2-9查步骤列表(边界)-D3-9判断高中基层步骤-高/中/基层操作场景不能为空",false);
      judgeTopMidBasicStepRespDto = fwAppOffStateClient.judgeTopMidBasicStep(judgeTopMidBasicStepReqDto).getData();
      
      
      judgeTopMidBasicStepRespDto_1 = judgeTopMidBasicStepRespDto;
    
BffQueryStepListBorderRespDto retData = new BffQueryStepListBorderRespDto();
  if(judgeTopMidBasicStepRespDto_1!=null){
      retData.setTopMidBasicStepList(judgeTopMidBasicStepRespDto_1.getTopMidBasicStepList().stream().map(item -> BeanUtil.toBean(item, BffTopMidBasicStepDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:388498_1
    }
  

  
  
return retData;
  }
/**
   * B3-13查业务服务内容当前步骤(管理)[3056]
   * gen by moon at 10/8/2022, 3:09:59 AM
   */
    @Trace(operationName = "B3-13查业务服务内容当前步骤(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffQueryBizAppServiceContCurrentBstepDetailRespDto queryBizAppServiceContCurrentBstepDetail(BffQueryBizAppServiceContCurrentBstepDetailReqDto reqDto){
      
       
       QueryContCurrentBstepDetailRespDto queryContCurrentBstepDetailRespDto_1 =null;
//步骤0: D3-13查内容当前行为步骤 - queryContCurrentBstepDetail
     QueryContCurrentBstepDetailRespDto queryContCurrentBstepDetailRespDto = null;
    QueryContCurrentBstepDetailReqDto queryContCurrentBstepDetailReqDto=new QueryContCurrentBstepDetailReqDto();
  if(reqDto!=null){
      queryContCurrentBstepDetailReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:101814_1
queryContCurrentBstepDetailReqDto.setStepObj(reqDto.getStepObj());//SimpleFieldAssign//sourceId:101813_1
    }
  
    /*D3-13查内容当前行为步骤[2951]   */
    Assert.isNull(queryContCurrentBstepDetailReqDto.getEntityId(),"B3-13查业务服务内容当前步骤(管理)-D3-13查内容当前行为步骤-步骤内容实例ID不能为空",false);
Assert.isNull(queryContCurrentBstepDetailReqDto.getStepObj(),"B3-13查业务服务内容当前步骤(管理)-D3-13查内容当前行为步骤-步骤使用对象表不能为空",false);
      queryContCurrentBstepDetailRespDto = fwAppOffStateClient.queryContCurrentBstepDetail(queryContCurrentBstepDetailReqDto).getData();
      
      
      queryContCurrentBstepDetailRespDto_1 = queryContCurrentBstepDetailRespDto;
    
BffQueryBizAppServiceContCurrentBstepDetailRespDto retData = new BffQueryBizAppServiceContCurrentBstepDetailRespDto();
  if(queryContCurrentBstepDetailRespDto_1!=null){
      retData.setBehaviorCurrentStepId(queryContCurrentBstepDetailRespDto_1.getBehaviorCurrentStepId());//SimpleFieldAssign//sourceId:101818_1
retData.setStepNameCode(queryContCurrentBstepDetailRespDto_1.getStepNameCode());//SimpleFieldAssign//sourceId:101819_1
    }
  

  
  
return retData;
  }
/**
   * B3-11设基层完成安排(管理)[3059]
   * gen by moon at 10/24/2023, 3:33:33 AM
   */
    @Trace(operationName = "B3-11设基层完成安排(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffCompleteBasicSetAchieveRespDto completeBasicSetAchieve(BffCompleteBasicSetAchieveReqDto reqDto){
      
       
       ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto_1 =null;
//virtualUsage D3执行基层导向步骤房间  51055
      ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto = null;
    ImplementTopMidBasicGuideStepRoomReqDto implementTopMidBasicGuideStepRoomReqDto=new ImplementTopMidBasicGuideStepRoomReqDto();
  implementTopMidBasicGuideStepRoomReqDto.setAchieveArrange("1");//CUSTOM_CONVENTION//sourceId:1203718_1_51055
implementTopMidBasicGuideStepRoomReqDto.setBatchOperateScene("BASIC");//sourceId:1203719_1_51055

    /*D3执行基层导向步骤房间[7600]   */
    Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getAchieveArrange(),"B3-11设基层完成安排(管理)-D3执行基层导向步骤房间-完成安排不能为空",false);
Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getBatchOperateScene(),"B3-11设基层完成安排(管理)-D3执行基层导向步骤房间-高/中/基层操作场景不能为空",false);
      implementTopMidBasicGuideStepRoomRespDto = fwAppEvaSystemClient.implementTopMidBasicGuideStepRoom(implementTopMidBasicGuideStepRoomReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      implementTopMidBasicGuideStepRoomRespDto_1 = implementTopMidBasicGuideStepRoomRespDto;
if((implementTopMidBasicGuideStepRoomRespDto!= null&& implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue() != null )) {
        //if(D3执行基层导向步骤房间.进入步骤房间值 值不等于空 )  51056

     UpdateBasicSetAchieveComRespDto updateBasicSetAchieveComRespDto = null;
    if(implementTopMidBasicGuideStepRoomRespDto !=null){
    UpdateBasicSetAchieveComReqDto updateBasicSetAchieveComReqDto=new UpdateBasicSetAchieveComReqDto();
  updateBasicSetAchieveComReqDto.setBatchOperateScene("BASIC");//sourceId:1203729_1_51057
updateBasicSetAchieveComReqDto.setIsComplete("TRUE");//sourceId:1203731_1_51057
  if(reqDto!=null){
      updateBasicSetAchieveComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:425743_1_51057
updateBasicSetAchieveComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:425744_1_51057
    }
if(implementTopMidBasicGuideStepRoomRespDto!=null){
      updateBasicSetAchieveComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:1203730_1_51057
    }
  
    /*D3-11修改基层设置完成(公共)[3764]   */
    Assert.isNull(updateBasicSetAchieveComReqDto.getTargetId(),"B3-11设基层完成安排(管理)-D3-11修改基层设置完成(公共)-目标ID不能为空",false);
Assert.isNull(updateBasicSetAchieveComReqDto.getDeptId(),"B3-11设基层完成安排(管理)-D3-11修改基层设置完成(公共)-部门ID不能为空",false);
Assert.isNull(updateBasicSetAchieveComReqDto.getBatchOperateScene(),"B3-11设基层完成安排(管理)-D3-11修改基层设置完成(公共)-高/中/基层操作场景不能为空",false);
Assert.isNull(updateBasicSetAchieveComReqDto.getStepRoomValue(),"B3-11设基层完成安排(管理)-D3-11修改基层设置完成(公共)-进入步骤房间值不能为空",false);
Assert.isNull(updateBasicSetAchieveComReqDto.getIsComplete(),"B3-11设基层完成安排(管理)-D3-11修改基层设置完成(公共)-是否已完成不能为空",false);
      updateBasicSetAchieveComRespDto = fwAppOffStateClient.updateBasicSetAchieveCom(updateBasicSetAchieveComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      

    
           }
      }
BffCompleteBasicSetAchieveRespDto retData = new BffCompleteBasicSetAchieveRespDto();
  if(implementTopMidBasicGuideStepRoomRespDto_1!=null){
      retData.setStepNameCode(implementTopMidBasicGuideStepRoomRespDto_1.getStepNameCode());//SimpleFieldAssign//sourceId:1203732_1
    }
  

  
  
return retData;
  }
/**
   * B3-13判断高层第1步可进入的房间(管理)[4403]
   * gen by moon at 10/15/2022, 10:26:51 PM
   */
    @Trace(operationName = "B3-13判断高层第1步可进入的房间(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffJudgeTopStepOneOperateTypeRespDto judgeTopStepOneOperateType(BffJudgeTopStepOneOperateTypeReqDto reqDto){
      
       
       JudgeTopStepOneOperateTypeRespDto judgeTopStepOneOperateTypeRespDto_1 =null;
//步骤0: D3-13判断高层第1步操作类型 - judgeTopStepOneOperateType
     JudgeTopStepOneOperateTypeRespDto judgeTopStepOneOperateTypeRespDto = null;
    JudgeTopStepOneOperateTypeReqDto judgeTopStepOneOperateTypeReqDto=new JudgeTopStepOneOperateTypeReqDto();
  if(reqDto!=null){
      judgeTopStepOneOperateTypeReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:339477_1
judgeTopStepOneOperateTypeReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:339478_1
    }
  
    /*D3-13判断高层第1步操作类型[4404]   */
    Assert.isNull(judgeTopStepOneOperateTypeReqDto.getTargetId(),"B3-13判断高层第1步可进入的房间(管理)-D3-13判断高层第1步操作类型-目标ID不能为空",false);
Assert.isNull(judgeTopStepOneOperateTypeReqDto.getEvaluationTemplateId(),"B3-13判断高层第1步可进入的房间(管理)-D3-13判断高层第1步操作类型-归属评价模板ID不能为空",false);
      judgeTopStepOneOperateTypeRespDto = fwAppOffStateClient.judgeTopStepOneOperateType(judgeTopStepOneOperateTypeReqDto).getData();
      
      
      judgeTopStepOneOperateTypeRespDto_1 = judgeTopStepOneOperateTypeRespDto;
    
BffJudgeTopStepOneOperateTypeRespDto retData = new BffJudgeTopStepOneOperateTypeRespDto();
  if(judgeTopStepOneOperateTypeRespDto_1!=null){
      retData.setTargetTaskDivRoom(judgeTopStepOneOperateTypeRespDto_1.getTargetTaskDivRoom());//SimpleFieldAssign//sourceId:379973_1
retData.setDeptTargetWeightSetRoom(judgeTopStepOneOperateTypeRespDto_1.getDeptTargetWeightSetRoom());//SimpleFieldAssign//sourceId:339488_1
retData.setPalnCompileAchieveRoom(judgeTopStepOneOperateTypeRespDto_1.getPalnCompileAchieveRoom());//SimpleFieldAssign//sourceId:339489_1
    }
  

  
  
return retData;
  }
/**
   * B3-11查询高层目标检查项状态(管理)[2928]
   * gen by moon at 9/15/2022, 12:26:47 AM
   */
    @Trace(operationName = "B3-11查询高层目标检查项状态(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffQueryTopTargetCheckItemStatusDetailRespDto queryTopTargetCheckItemStatusDetail(BffQueryTopTargetCheckItemStatusDetailReqDto reqDto){
      
       
       QueryBizAppCheckItemStatDetailRespDto queryBizAppCheckItemStatDetailRespDto_1 =null;
//步骤0: D3-11查业务应用校验项状态详情 - queryBizAppCheckItemStatDetail
     QueryBizAppCheckItemStatDetailRespDto queryBizAppCheckItemStatDetailRespDto = null;
    QueryBizAppCheckItemStatDetailReqDto queryBizAppCheckItemStatDetailReqDto=new QueryBizAppCheckItemStatDetailReqDto();
  queryBizAppCheckItemStatDetailReqDto.setObjectTypeCode("OMS_TARGET");//sourceId:94423_1
if(reqDto!=null){
      queryBizAppCheckItemStatDetailReqDto.setEntityId(reqDto.getEntityId());//sourceId:94422_1
queryBizAppCheckItemStatDetailReqDto.setCheckItemCode(reqDto.getCheckItemCode());//sourceId:94421_1
    }
  
    /*D3-11查业务应用校验项状态详情[2930]   */
    Assert.isNull(queryBizAppCheckItemStatDetailReqDto.getEntityId(),"B3-11查询高层目标检查项状态(管理)-D3-11查业务应用校验项状态详情-内容对象实例ID不能为空",false);
Assert.isNull(queryBizAppCheckItemStatDetailReqDto.getObjectTypeCode(),"B3-11查询高层目标检查项状态(管理)-D3-11查业务应用校验项状态详情-内容对象类型编码不能为空",false);
Assert.isNull(queryBizAppCheckItemStatDetailReqDto.getCheckItemCode(),"B3-11查询高层目标检查项状态(管理)-D3-11查业务应用校验项状态详情-检查项标识不能为空",false);
      queryBizAppCheckItemStatDetailRespDto = fwAppOffStateClient.queryBizAppCheckItemStatDetail(queryBizAppCheckItemStatDetailReqDto).getData();
      
      
      queryBizAppCheckItemStatDetailRespDto_1 = queryBizAppCheckItemStatDetailRespDto;
    
BffQueryTopTargetCheckItemStatusDetailRespDto retData = new BffQueryTopTargetCheckItemStatusDetailRespDto();
  if(queryBizAppCheckItemStatDetailRespDto_1!=null){
      retData.setStatusCheckItemId(queryBizAppCheckItemStatDetailRespDto_1.getStatusCheckItemId());//sourceId:94427_1
retData.setIsComplete(queryBizAppCheckItemStatDetailRespDto_1.getIsComplete());//sourceId:94429_1
    }
  

  
  
return retData;
  }
/**
   * B3-11查询目标内容仪表盘列表(管理)[3960]
   * gen by moon at 10/8/2022, 3:10:13 AM
   */
    @Trace(operationName = "B3-11查询目标内容仪表盘列表(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffQueryTargetContCheckItemPanelListRespDto queryTargetContCheckItemPanelList(BffQueryTargetContCheckItemPanelListReqDto reqDto){
      
       
       QueryTargetContCheckItemPanelListRespDto queryTargetContCheckItemPanelListRespDto_1 =null;
BatchQueryCheckItemRespDto batchQueryCheckItemRespDto_1 =null;
//步骤0: D3-3查询目标内容仪表盘列表 - queryTargetContCheckItemPanelList
     QueryTargetContCheckItemPanelListRespDto queryTargetContCheckItemPanelListRespDto = null;
    QueryTargetContCheckItemPanelListReqDto queryTargetContCheckItemPanelListReqDto=new QueryTargetContCheckItemPanelListReqDto();
  if(reqDto!=null){
      queryTargetContCheckItemPanelListReqDto.setCheckObjectTypeId(reqDto.getCheckObjectTypeId());//SimpleFieldAssign//sourceId:203985_1
queryTargetContCheckItemPanelListReqDto.setCheckObjectTypeCode(reqDto.getCheckObjectTypeCode());//SimpleFieldAssign//sourceId:203986_1
    }
  
    /*D3-3查询目标内容仪表盘列表[3961]   */
    Assert.isNull(queryTargetContCheckItemPanelListReqDto.getCheckObjectTypeId(),"B3-11查询目标内容仪表盘列表(管理)-D3-3查询目标内容仪表盘列表-检查内容对象ID 不能为空",false);
Assert.isNull(queryTargetContCheckItemPanelListReqDto.getCheckObjectTypeCode(),"B3-11查询目标内容仪表盘列表(管理)-D3-3查询目标内容仪表盘列表-检查内容对象类型编码不能为空",false);
      queryTargetContCheckItemPanelListRespDto = fwAppOffStateClient.queryTargetContCheckItemPanelList(queryTargetContCheckItemPanelListReqDto).getData();
      
      
      queryTargetContCheckItemPanelListRespDto_1 = queryTargetContCheckItemPanelListRespDto;
    
//步骤1: D3-11批量查询检查项 - batchQueryCheckItem
     BatchQueryCheckItemRespDto batchQueryCheckItemRespDto = null;
    if(queryTargetContCheckItemPanelListRespDto !=null){
          BatchQueryCheckItemReqDto batchQueryCheckItemReqDto=new BatchQueryCheckItemReqDto();
  batchQueryCheckItemReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:203998_1
if(queryTargetContCheckItemPanelListRespDto!=null){
      batchQueryCheckItemReqDto.setCheckItemList(queryTargetContCheckItemPanelListRespDto.getCheckItemPanelList().stream().map(item->item.getCheckItemCode())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:203995_1
    }
  
    /*D3-11批量查询检查项[3978]   */
    Assert.isNull(batchQueryCheckItemReqDto.getSubjectLifeCycle(),"B3-11查询目标内容仪表盘列表(管理)-D3-11批量查询检查项-主体生命周期不能为空",false);
      batchQueryCheckItemRespDto = fwAppOffStateClient.batchQueryCheckItem(batchQueryCheckItemReqDto).getData();
      
      
      batchQueryCheckItemRespDto_1 = batchQueryCheckItemRespDto;
           }
    
BffQueryTargetContCheckItemPanelListRespDto retData = new BffQueryTargetContCheckItemPanelListRespDto();
  //sourceId:204008_1
  

  
  
return retData;
  }
/**
   * B3-11查询中层目标安排检查项完成情况(管理)[3739]
   * gen by moon at 9/23/2022, 5:58:39 AM
   */
    @Trace(operationName = "B3-11查询中层目标安排检查项完成情况(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffQueryMidExecuteTargetArrangeStateDetailRespDto queryMidExecuteTargetArrangeStateDetail(BffQueryMidExecuteTargetArrangeStateDetailReqDto reqDto){
      
       
       BatchQueryMidExecuteTargetCheckItemRespDto batchQueryMidExecuteTargetCheckItemRespDto_1 =null;
//步骤0: D3-11查询部门目标任务书ID列表(公共) - queryDeptTargetTaskBookIdListCom
     QueryDeptTargetTaskBookIdListComRespDto queryDeptTargetTaskBookIdListComRespDto = null;
    QueryDeptTargetTaskBookIdListComReqDto queryDeptTargetTaskBookIdListComReqDto=new QueryDeptTargetTaskBookIdListComReqDto();
  if(reqDto!=null){
//      queryDeptTargetTaskBookIdListComReqDto.setTargetId(reqDto.getTargetId());//sourceId:217250_1
    }
  
    /*D3-11查询部门目标任务书ID列表(公共)[4026]   */
//    Assert.isNull(queryDeptTargetTaskBookIdListComReqDto.getTargetId(),"B3-11查询中层目标安排检查项完成情况(管理)-D3-11查询部门目标任务书ID列表(公共)-冗余目标ID不能为空",false);
      queryDeptTargetTaskBookIdListComRespDto = fwAppTargetCycleClient.queryDeptTargetTaskBookIdListCom(queryDeptTargetTaskBookIdListComReqDto).getData();
      
      
      
    
//步骤1: D3-11批量查询中层执行目标安排检查项 - batchQueryMidExecuteTargetCheckItem
     BatchQueryMidExecuteTargetCheckItemRespDto batchQueryMidExecuteTargetCheckItemRespDto = null;
    if(queryDeptTargetTaskBookIdListComRespDto !=null){
          BatchQueryMidExecuteTargetCheckItemReqDto batchQueryMidExecuteTargetCheckItemReqDto=new BatchQueryMidExecuteTargetCheckItemReqDto();
  if(queryDeptTargetTaskBookIdListComRespDto!=null){
      batchQueryMidExecuteTargetCheckItemReqDto.setBizAppCheckItemStatList(queryDeptTargetTaskBookIdListComRespDto.getDeptTargetTaskBookIdList().stream().map(item->item.getEvaObjTargetCycleId())
        .collect(Collectors.toList()));//sourceId:217466_1
    }
if(reqDto!=null){
      batchQueryMidExecuteTargetCheckItemReqDto.setCheckItemCode(reqDto.getCheckItemCode());//sourceId:341399_1
    }
  
    /*D3-11批量查询中层执行目标安排检查项[4027]   */
    Assert.isNull(batchQueryMidExecuteTargetCheckItemReqDto.getCheckItemCode(),"B3-11查询中层目标安排检查项完成情况(管理)-D3-11批量查询中层执行目标安排检查项-检查项标识不能为空",false);
      batchQueryMidExecuteTargetCheckItemRespDto = fwAppOffStateClient.batchQueryMidExecuteTargetCheckItem(batchQueryMidExecuteTargetCheckItemReqDto).getData();
      
      
      batchQueryMidExecuteTargetCheckItemRespDto_1 = batchQueryMidExecuteTargetCheckItemRespDto;
           }
    
BffQueryMidExecuteTargetArrangeStateDetailRespDto retData = new BffQueryMidExecuteTargetArrangeStateDetailRespDto();
  if(batchQueryMidExecuteTargetCheckItemRespDto_1!=null){
      retData.setEvaObjTargetCycleList(batchQueryMidExecuteTargetCheckItemRespDto_1.getBizAppCheckItemStatList().stream().map(item -> BeanUtil.toBean(item, BffEvaObjTargetCycleDto.class)).collect(Collectors.toList()));//sourceId:329177_1
retData.setOutputNum(batchQueryMidExecuteTargetCheckItemRespDto_1.getOutputNum());//sourceId:217471_1
    }
  

  
  
return retData;
  }
/**
   * B3-11设中层完成安排(管理)[3039]
   * gen by moon at 10/24/2023, 3:33:12 AM
   */
    @Trace(operationName = "B3-11设中层完成安排(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffCompleteMidSetAchieveRespDto completeMidSetAchieve(BffCompleteMidSetAchieveReqDto reqDto){
      
       
       ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto_1 =null;
//virtualUsage D3执行中层导向步骤房间  51052
      ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto = null;
    ImplementTopMidBasicGuideStepRoomReqDto implementTopMidBasicGuideStepRoomReqDto=new ImplementTopMidBasicGuideStepRoomReqDto();
  implementTopMidBasicGuideStepRoomReqDto.setAchieveArrange("1");//CUSTOM_CONVENTION//sourceId:1203695_1_51052
implementTopMidBasicGuideStepRoomReqDto.setBatchOperateScene("MID");//sourceId:1203696_1_51052
if(reqDto!=null){
      implementTopMidBasicGuideStepRoomReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1203697_1_51052
implementTopMidBasicGuideStepRoomReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1203698_1_51052
    }

    /*D3执行中层导向步骤房间[7600]   */
    Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getAchieveArrange(),"B3-11设中层完成安排(管理)-D3执行中层导向步骤房间-完成安排不能为空",false);
Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getBatchOperateScene(),"B3-11设中层完成安排(管理)-D3执行中层导向步骤房间-高/中/基层操作场景不能为空",false);
Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getDeptId(),"B3-11设中层完成安排(管理)-D3执行中层导向步骤房间-一级部门ID不能为空",false);
Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getEvaluationTemplateId(),"B3-11设中层完成安排(管理)-D3执行中层导向步骤房间-冗余评价模板ID不能为空",false);
      implementTopMidBasicGuideStepRoomRespDto = fwAppEvaSystemClient.implementTopMidBasicGuideStepRoom(implementTopMidBasicGuideStepRoomReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      implementTopMidBasicGuideStepRoomRespDto_1 = implementTopMidBasicGuideStepRoomRespDto;
if((implementTopMidBasicGuideStepRoomRespDto!= null&& implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue() != null )) {
        //if(D3执行中层导向步骤房间.进入步骤房间值 值不等于空 )  51053

     UpdateMidSetAchieveRespDto updateMidSetAchieveRespDto = null;
    UpdateMidSetAchieveReqDto updateMidSetAchieveReqDto=new UpdateMidSetAchieveReqDto();
  if(reqDto!=null){
      updateMidSetAchieveReqDto.setTargetObjList(reqDto.getTargetObjList());//list-field-assign//sourceId:202508_1_51054
updateMidSetAchieveReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:210263_1_51054
updateMidSetAchieveReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:210265_1_51054
updateMidSetAchieveReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:334835_1_51054
updateMidSetAchieveReqDto.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:210266_1_51054
    }
  
    /*D3-11修改中层设置完成[3747]   */
    Assert.isNull(updateMidSetAchieveReqDto.getDeptId(),"B3-11设中层完成安排(管理)-D3-11修改中层设置完成-部门ID不能为空",false);
Assert.isNull(updateMidSetAchieveReqDto.getTargetId(),"B3-11设中层完成安排(管理)-D3-11修改中层设置完成-冗余目标ID不能为空",false);
Assert.isNull(updateMidSetAchieveReqDto.getEvaluationTemplateId(),"B3-11设中层完成安排(管理)-D3-11修改中层设置完成-冗余评价模板ID不能为空",false);
Assert.isNull(updateMidSetAchieveReqDto.getBatchCode(),"B3-11设中层完成安排(管理)-D3-11修改中层设置完成-批次标识不能为空",false);
      updateMidSetAchieveRespDto = fwAppOffStateClient.updateMidSetAchieve(updateMidSetAchieveReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      

    
      }
BffCompleteMidSetAchieveRespDto retData = new BffCompleteMidSetAchieveRespDto();
  if(implementTopMidBasicGuideStepRoomRespDto_1!=null){
      retData.setStepNameCode(implementTopMidBasicGuideStepRoomRespDto_1.getStepNameCode());//SimpleFieldAssign//sourceId:1203699_1
    }
  

  
  
return retData;
  }
/**
   * B3-11查目标分类检查仪表盘列表(管理)[2715]
   * gen by moon at 10/20/2022, 10:06:19 AM
   */
    @Trace(operationName = "B3-11查目标分类检查仪表盘列表(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffQueryTargetCatCheckItemPanelListRespDto queryTargetCatCheckItemPanelList(BffQueryTargetCatCheckItemPanelListReqDto reqDto){
      
       
       QueryCheckItemPanelListRespDto queryCheckItemPanelListRespDto_1 =null;
BatchQueryCheckItemRespDto batchQueryCheckItemRespDto_1 =null;
JudgeShoppingTrolleySaveTermRespDto judgeShoppingTrolleySaveTermRespDto_1 =null;
//步骤0: D3-11查检查仪表盘列表 - queryCheckItemPanelList
     QueryCheckItemPanelListRespDto queryCheckItemPanelListRespDto = null;
    QueryCheckItemPanelListReqDto queryCheckItemPanelListReqDto=new QueryCheckItemPanelListReqDto();
  queryCheckItemPanelListReqDto.setCheckObjectTypeCode("OMS_TARGET_CATEGORY");//sourceId:84779_1
if(reqDto!=null){
      queryCheckItemPanelListReqDto.setCheckObjectTypeId(reqDto.getCheckObjectTypeId());//SimpleFieldAssign//sourceId:84710_1
    }
  
    /*D3-11查检查仪表盘列表[2716]   */
    Assert.isNull(queryCheckItemPanelListReqDto.getCheckObjectTypeId(),"B3-11查目标分类检查仪表盘列表(管理)-D3-11查检查仪表盘列表-检查内容对象ID 不能为空",false);
Assert.isNull(queryCheckItemPanelListReqDto.getCheckObjectTypeCode(),"B3-11查目标分类检查仪表盘列表(管理)-D3-11查检查仪表盘列表-检查内容对象类型编码不能为空",false);
      queryCheckItemPanelListRespDto = fwAppOffStateClient.queryCheckItemPanelList(queryCheckItemPanelListReqDto).getData();
      
      
      queryCheckItemPanelListRespDto_1 = queryCheckItemPanelListRespDto;
    
//步骤1: D3-11批量查询检查项 - batchQueryCheckItem
     BatchQueryCheckItemRespDto batchQueryCheckItemRespDto = null;
    if(queryCheckItemPanelListRespDto !=null){
          BatchQueryCheckItemReqDto batchQueryCheckItemReqDto=new BatchQueryCheckItemReqDto();
  batchQueryCheckItemReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:218080_1
if(queryCheckItemPanelListRespDto!=null){
      batchQueryCheckItemReqDto.setCheckItemList(queryCheckItemPanelListRespDto.getTargetDashboardCompletionStatusList().stream().map(item->item.getCheckItemCode())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:218079_1
    }
  
    /*D3-11批量查询检查项[3978]   */
    Assert.isNull(batchQueryCheckItemReqDto.getSubjectLifeCycle(),"B3-11查目标分类检查仪表盘列表(管理)-D3-11批量查询检查项-主体生命周期不能为空",false);
      batchQueryCheckItemRespDto = fwAppOffStateClient.batchQueryCheckItem(batchQueryCheckItemReqDto).getData();
      
      
      batchQueryCheckItemRespDto_1 = batchQueryCheckItemRespDto;
           }
    
//步骤2: D3-11判断购物车确认保存操作条件 - judgeShoppingTrolleySaveTerm
     JudgeShoppingTrolleySaveTermRespDto judgeShoppingTrolleySaveTermRespDto = null;
    JudgeShoppingTrolleySaveTermReqDto judgeShoppingTrolleySaveTermReqDto=new JudgeShoppingTrolleySaveTermReqDto();
  judgeShoppingTrolleySaveTermReqDto.setObjectTypeCode("OMS_TARGET_OBJECTIVE");//sourceId:221686_1
if(reqDto!=null){
      judgeShoppingTrolleySaveTermReqDto.setBizAppCheckItemStatList(reqDto.getTargetObjList());//list-field-assign//sourceId:221685_1
    }
  
    /*D3-11判断购物车确认保存操作条件[4041]   */
    Assert.isNull(judgeShoppingTrolleySaveTermReqDto.getObjectTypeCode(),"B3-11查目标分类检查仪表盘列表(管理)-D3-11判断购物车确认保存操作条件-内容对象类型编码不能为空",false);
      judgeShoppingTrolleySaveTermRespDto = fwAppOffStateClient.judgeShoppingTrolleySaveTerm(judgeShoppingTrolleySaveTermReqDto).getData();
      
      
      judgeShoppingTrolleySaveTermRespDto_1 = judgeShoppingTrolleySaveTermRespDto;
    
BffQueryTargetCatCheckItemPanelListRespDto retData = new BffQueryTargetCatCheckItemPanelListRespDto();
  //数据集融合  MoreListToOneSource
        if(queryCheckItemPanelListRespDto_1!= null && !CollectionUtil.isEmpty(queryCheckItemPanelListRespDto_1.getTargetDashboardCompletionStatusList()) ){
          for (TargetDashboardCompletionStatusDto targetDashboardCompletionStatusDto : queryCheckItemPanelListRespDto_1.getTargetDashboardCompletionStatusList()) {
              BffCheckItemPanelDto retElm = new BffCheckItemPanelDto();
             if(queryCheckItemPanelListRespDto_1!=null){
      retElm.setCheckItemPanelUpdateId(targetDashboardCompletionStatusDto.getCheckItemPanelUpdateId());//SimpleFieldAssign//sourceId:109153_2
retElm.setCheckItemCode(targetDashboardCompletionStatusDto.getCheckItemCode());//SimpleFieldAssign//sourceId:109154_2
retElm.setTargetValue(targetDashboardCompletionStatusDto.getTargetValue());//SimpleFieldAssign//sourceId:109155_2
retElm.setActualValue(targetDashboardCompletionStatusDto.getActualValue());//SimpleFieldAssign//sourceId:109156_2
retElm.setIsComplete(targetDashboardCompletionStatusDto.getIsComplete());//SimpleFieldAssign//sourceId:109157_2
    }
              retData.getCheckItemPanelList().add(retElm);
               if(batchQueryCheckItemRespDto_1!= null){
          for (CheckItemListDto checkItemListDto : batchQueryCheckItemRespDto_1.getCheckItemList()) {
                if (checkItemListDto.getCheckItemId().equals(targetDashboardCompletionStatusDto.getCheckItemId())) {
                 if(batchQueryCheckItemRespDto_1!=null){
      retElm.setCheckItemId(checkItemListDto.getCheckItemId());//SimpleFieldAssign//sourceId:108979_2
retElm.setCheckItemName(checkItemListDto.getCheckItemName());//SimpleFieldAssign//sourceId:82275_2
    }
                }
            }
          }

          }
        }//sourceId:84713_1
if(judgeShoppingTrolleySaveTermRespDto_1!=null){
      retData.setOutputNum(judgeShoppingTrolleySaveTermRespDto_1.getOutputNum());//SimpleFieldAssign//sourceId:221690_1
    }
if(queryCheckItemPanelListRespDto_1!=null){
      retData.setMolecule(queryCheckItemPanelListRespDto_1.getMolecule());//SimpleFieldAssign//sourceId:384233_1
retData.setDenominator(queryCheckItemPanelListRespDto_1.getDenominator());//SimpleFieldAssign//sourceId:384234_1
    }


  
  
return retData;
  }
/**
   * B3-11查询指标仪表盘列表(管理)[4085]
   * gen by moon at 10/20/2022, 10:06:21 AM
   */
    @Trace(operationName = "B3-11查询指标仪表盘列表(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffQueryTargetObjCheckItemPanelListRespDto queryTargetObjCheckItemPanelList(BffQueryTargetObjCheckItemPanelListReqDto reqDto){
      
       
       QueryCheckItemPanelListRespDto queryCheckItemPanelListRespDto_1 =null;
BatchQueryCheckItemRespDto batchQueryCheckItemRespDto_1 =null;
JudgeShoppingTrolleySaveTermRespDto judgeShoppingTrolleySaveTermRespDto_1 =null;
//步骤0: D3-11查检查仪表盘列表 - queryCheckItemPanelList
     QueryCheckItemPanelListRespDto queryCheckItemPanelListRespDto = null;
    QueryCheckItemPanelListReqDto queryCheckItemPanelListReqDto=new QueryCheckItemPanelListReqDto();
  queryCheckItemPanelListReqDto.setCheckObjectTypeCode("OMS_TARGET_OBJECTIVE");//sourceId:221848_1
if(reqDto!=null){
      queryCheckItemPanelListReqDto.setCheckObjectTypeId(reqDto.getCheckObjectTypeId());//SimpleFieldAssign//sourceId:221846_1
    }
  
    /*D3-11查检查仪表盘列表[2716]   */
    Assert.isNull(queryCheckItemPanelListReqDto.getCheckObjectTypeId(),"B3-11查询指标仪表盘列表(管理)-D3-11查检查仪表盘列表-检查内容对象ID 不能为空",false);
Assert.isNull(queryCheckItemPanelListReqDto.getCheckObjectTypeCode(),"B3-11查询指标仪表盘列表(管理)-D3-11查检查仪表盘列表-检查内容对象类型编码不能为空",false);
      queryCheckItemPanelListRespDto = fwAppOffStateClient.queryCheckItemPanelList(queryCheckItemPanelListReqDto).getData();
      
      
      queryCheckItemPanelListRespDto_1 = queryCheckItemPanelListRespDto;
    
//步骤1: D3-11批量查询检查项 - batchQueryCheckItem
     BatchQueryCheckItemRespDto batchQueryCheckItemRespDto = null;
    if(queryCheckItemPanelListRespDto !=null){
          BatchQueryCheckItemReqDto batchQueryCheckItemReqDto=new BatchQueryCheckItemReqDto();
  batchQueryCheckItemReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:221850_1
if(queryCheckItemPanelListRespDto!=null){
      batchQueryCheckItemReqDto.setCheckItemList(queryCheckItemPanelListRespDto.getTargetDashboardCompletionStatusList().stream().map(item->item.getCheckItemCode())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:221849_1
    }
  
    /*D3-11批量查询检查项[3978]   */
    Assert.isNull(batchQueryCheckItemReqDto.getSubjectLifeCycle(),"B3-11查询指标仪表盘列表(管理)-D3-11批量查询检查项-主体生命周期不能为空",false);
      batchQueryCheckItemRespDto = fwAppOffStateClient.batchQueryCheckItem(batchQueryCheckItemReqDto).getData();
      
      
      batchQueryCheckItemRespDto_1 = batchQueryCheckItemRespDto;
           }
    
//步骤2: D3-11判断购物车确认保存操作条件 - judgeShoppingTrolleySaveTerm
     JudgeShoppingTrolleySaveTermRespDto judgeShoppingTrolleySaveTermRespDto = null;
    JudgeShoppingTrolleySaveTermReqDto judgeShoppingTrolleySaveTermReqDto=new JudgeShoppingTrolleySaveTermReqDto();
  judgeShoppingTrolleySaveTermReqDto.setObjectTypeCode("OMS_TARGET_OBJECTIVE");//sourceId:221853_1
if(reqDto!=null){
      judgeShoppingTrolleySaveTermReqDto.setBizAppCheckItemStatList(reqDto.getTargetObjList());//list-field-assign//sourceId:221852_1
    }
  
    /*D3-11判断购物车确认保存操作条件[4041]   */
    Assert.isNull(judgeShoppingTrolleySaveTermReqDto.getObjectTypeCode(),"B3-11查询指标仪表盘列表(管理)-D3-11判断购物车确认保存操作条件-内容对象类型编码不能为空",false);
      judgeShoppingTrolleySaveTermRespDto = fwAppOffStateClient.judgeShoppingTrolleySaveTerm(judgeShoppingTrolleySaveTermReqDto).getData();
      
      
      judgeShoppingTrolleySaveTermRespDto_1 = judgeShoppingTrolleySaveTermRespDto;
    
BffQueryTargetObjCheckItemPanelListRespDto retData = new BffQueryTargetObjCheckItemPanelListRespDto();
  //数据集融合  MoreListToOneSource
        if(queryCheckItemPanelListRespDto_1!= null && !CollectionUtil.isEmpty(queryCheckItemPanelListRespDto_1.getTargetDashboardCompletionStatusList()) ){
          for (TargetDashboardCompletionStatusDto targetDashboardCompletionStatusDto : queryCheckItemPanelListRespDto_1.getTargetDashboardCompletionStatusList()) {
              BffCheckItemPanelDto retElm = new BffCheckItemPanelDto();
             if(queryCheckItemPanelListRespDto_1!=null){
      retElm.setCheckItemPanelUpdateId(targetDashboardCompletionStatusDto.getCheckItemPanelUpdateId());//SimpleFieldAssign//sourceId:109158_2
retElm.setCheckItemCode(targetDashboardCompletionStatusDto.getCheckItemCode());//SimpleFieldAssign//sourceId:109159_2
retElm.setTargetValue(targetDashboardCompletionStatusDto.getTargetValue());//SimpleFieldAssign//sourceId:109160_2
retElm.setActualValue(targetDashboardCompletionStatusDto.getActualValue());//SimpleFieldAssign//sourceId:109161_2
retElm.setIsComplete(targetDashboardCompletionStatusDto.getIsComplete());//SimpleFieldAssign//sourceId:109162_2
    }
              retData.getCheckItemPanelList().add(retElm);
               if(batchQueryCheckItemRespDto_1!= null){
          for (CheckItemListDto checkItemListDto : batchQueryCheckItemRespDto_1.getCheckItemList()) {
                if (checkItemListDto.getCheckItemId().equals(targetDashboardCompletionStatusDto.getCheckItemId())) {
                 if(batchQueryCheckItemRespDto_1!=null){
      retElm.setCheckItemId(checkItemListDto.getCheckItemId());//SimpleFieldAssign//sourceId:108978_2
retElm.setCheckItemName(checkItemListDto.getCheckItemName());//SimpleFieldAssign//sourceId:108957_2
    }
                }
            }
          }

          }
        }//sourceId:221857_1
if(judgeShoppingTrolleySaveTermRespDto_1!=null){
      retData.setOutputNum(judgeShoppingTrolleySaveTermRespDto_1.getOutputNum());//SimpleFieldAssign//sourceId:221858_1
    }
if(queryCheckItemPanelListRespDto_1!=null){
      retData.setMolecule(queryCheckItemPanelListRespDto_1.getMolecule());//SimpleFieldAssign//sourceId:384237_1
retData.setDenominator(queryCheckItemPanelListRespDto_1.getDenominator());//SimpleFieldAssign//sourceId:384238_1
    }


  
  
return retData;
  }
/**
   * B3-11中层修改目标安排(管理)[3048]
   * gen by moon at 2/17/2024, 10:58:59 PM
   */
    @Trace(operationName = "B3-11中层修改目标安排(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffUpdateMidEditRespDto updateMidEdit(BffUpdateMidEditReqDto reqDto){
      
       
       ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto_1 =null;
//virtualUsage D2执行上并发中层步骤变更锁(公共)  61174
      ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto = null;
    ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto=new ImplementConcBhvThemeLockComComReqDto();
  implementConcBhvThemeLockComComReqDto.setPreventConcurrentLockingUnlocking("LOCK");//sourceId:1540293_1_61174
implementConcBhvThemeLockComComReqDto.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540294_1_61174
implementConcBhvThemeLockComComReqDto.setDuration(Long.valueOf(15));//CUSTOM_CONVENTION//sourceId:1540296_1_61174
implementConcBhvThemeLockComComReqDto.setTimeUnitType("MINUTES");//sourceId:1540297_1_61174
implementConcBhvThemeLockComComReqDto.setHandlingMethodConcurrentLockFailure("CONCURRENT_LOCK_FAILURE_NO_ERROR_REPORTED");//sourceId:1540298_1_61174
if(reqDto!=null){
      implementConcBhvThemeLockComComReqDto.setCommPrimaryKey(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:1540295_1_61174
    }

    /*D2执行上并发中层步骤变更锁(公共)[8388]   */
    Assert.isNull(implementConcBhvThemeLockComComReqDto.getPreventConcurrentLockingUnlocking(),"B3-11中层修改目标安排(管理)-D2执行上并发中层步骤变更锁(公共)-防并发上锁or解锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getBehaviorThemeLockCode(),"B3-11中层修改目标安排(管理)-D2执行上并发中层步骤变更锁(公共)-行为主题锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getCommPrimaryKey(),"B3-11中层修改目标安排(管理)-D2执行上并发中层步骤变更锁(公共)-通用主键ID不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getDuration(),"B3-11中层修改目标安排(管理)-D2执行上并发中层步骤变更锁(公共)-锁定时长不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getTimeUnitType(),"B3-11中层修改目标安排(管理)-D2执行上并发中层步骤变更锁(公共)-时间单位类型不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getHandlingMethodConcurrentLockFailure(),"B3-11中层修改目标安排(管理)-D2执行上并发中层步骤变更锁(公共)-并发上锁失败处理方式不能为空",false);
      implementConcBhvThemeLockComComRespDto = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((implementConcBhvThemeLockComComRespDto!= null&&  implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() !=null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("EMPTY_LOCK_SUCCESSFUL"))) {
        //if(D2执行上并发中层步骤变更锁(公共).防并发上锁情况 等于 空上锁成功)  61175

      ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto = null;
    ImplementTopMidBasicGuideStepRoomReqDto implementTopMidBasicGuideStepRoomReqDto=new ImplementTopMidBasicGuideStepRoomReqDto();
  implementTopMidBasicGuideStepRoomReqDto.setEditTargetArrange("1");//CUSTOM_CONVENTION//sourceId:1203751_1_61176
implementTopMidBasicGuideStepRoomReqDto.setBatchOperateScene("MID");//sourceId:1203752_1_61176
if(reqDto!=null){
      implementTopMidBasicGuideStepRoomReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1203753_1_61176
implementTopMidBasicGuideStepRoomReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1203754_1_61176
    }

    /*D3执行中层导向步骤房间[7600]   */
    Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getEditTargetArrange(),"B3-11中层修改目标安排(管理)-D3执行中层导向步骤房间-修改目标安排不能为空",false);
Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getBatchOperateScene(),"B3-11中层修改目标安排(管理)-D3执行中层导向步骤房间-高/中/基层操作场景不能为空",false);
Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getDeptId(),"B3-11中层修改目标安排(管理)-D3执行中层导向步骤房间-一级部门ID不能为空",false);
Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getEvaluationTemplateId(),"B3-11中层修改目标安排(管理)-D3执行中层导向步骤房间-冗余评价模板ID不能为空",false);
      implementTopMidBasicGuideStepRoomRespDto = fwAppEvaSystemClient.implementTopMidBasicGuideStepRoom(implementTopMidBasicGuideStepRoomReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      implementTopMidBasicGuideStepRoomRespDto_1 = implementTopMidBasicGuideStepRoomRespDto;
ImplementTopMidBasicCurrentBstepJudgeComRespDto implementTopMidBasicCurrentBstepJudgeComRespDto = null;
    if(implementTopMidBasicGuideStepRoomRespDto !=null){
          ImplementTopMidBasicCurrentBstepJudgeComReqDto implementTopMidBasicCurrentBstepJudgeComReqDto=new ImplementTopMidBasicCurrentBstepJudgeComReqDto();
  implementTopMidBasicCurrentBstepJudgeComReqDto.setBatchOperateScene("MID");//sourceId:1540303_1_61177
if(reqDto!=null){
      implementTopMidBasicCurrentBstepJudgeComReqDto.setEntityId(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:1540299_1_61177
implementTopMidBasicCurrentBstepJudgeComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540300_1_61177
    }
if(implementTopMidBasicGuideStepRoomRespDto!=null){
      implementTopMidBasicCurrentBstepJudgeComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:1540302_1_61177
    }

    /*D3执行高中基层当前步骤判断(公共)[7303]   */
    Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getEntityId(),"B3-11中层修改目标安排(管理)-D3执行高中基层当前步骤判断(公共)-步骤内容实例ID不能为空",false);
Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getStepRoomValue(),"B3-11中层修改目标安排(管理)-D3执行高中基层当前步骤判断(公共)-进入步骤房间值不能为空",false);
Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getThemeContentId(),"B3-11中层修改目标安排(管理)-D3执行高中基层当前步骤判断(公共)-主题内容ID不能为空",false);
Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getBatchOperateScene(),"B3-11中层修改目标安排(管理)-D3执行高中基层当前步骤判断(公共)-高/中/基层操作场景不能为空",false);
      implementTopMidBasicCurrentBstepJudgeComRespDto = fwAppOffStateClient.implementTopMidBasicCurrentBstepJudgeCom(implementTopMidBasicCurrentBstepJudgeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((implementTopMidBasicCurrentBstepJudgeComRespDto!= null&&  implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() !=null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("FALSE")&&implementTopMidBasicGuideStepRoomRespDto!= null&&  implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue() !=null && implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue().equals("TARGET_TASK_DIV_ROOM"))) {
        //if((D3执行高中基层当前步骤判断(公共).是否相等 等于 否 and D3执行中层导向步骤房间.进入步骤房间值 等于 目标任务分工房间))  61178

     UpdateMidEditRespDto updateMidEditRespDto = null;
    if(implementTopMidBasicGuideStepRoomRespDto !=null){
    UpdateMidEditReqDto updateMidEditReqDto=new UpdateMidEditReqDto();
  if(reqDto!=null){
      updateMidEditReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:329981_1_61179
updateMidEditReqDto.setDeptTargetTaskBookId(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:856684_1_61179
updateMidEditReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:334829_1_61179
updateMidEditReqDto.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:856685_1_61179
updateMidEditReqDto.setBatchCurrentStatus(reqDto.getBatchCurrentStatus());//SimpleFieldAssign//sourceId:856686_1_61179
    }
if(implementTopMidBasicGuideStepRoomRespDto!=null){
      updateMidEditReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:340731_1_61179
    }

    /*D3-11中层修改安排[4553]   */
    Assert.isNull(updateMidEditReqDto.getDeptId(),"B3-11中层修改目标安排(管理)-D3-11中层修改安排-部门ID不能为空",false);
Assert.isNull(updateMidEditReqDto.getDeptTargetTaskBookId(),"B3-11中层修改目标安排(管理)-D3-11中层修改安排-部门目标任务书ID不能为空",false);
Assert.isNull(updateMidEditReqDto.getEvaluationTemplateId(),"B3-11中层修改目标安排(管理)-D3-11中层修改安排-冗余评价模板ID不能为空",false);
Assert.isNull(updateMidEditReqDto.getStepRoomValue(),"B3-11中层修改目标安排(管理)-D3-11中层修改安排-进入步骤房间值不能为空",false);
Assert.isNull(updateMidEditReqDto.getBatchCode(),"B3-11中层修改目标安排(管理)-D3-11中层修改安排-批次标识不能为空",false);
Assert.isNull(updateMidEditReqDto.getBatchCurrentStatus(),"B3-11中层修改目标安排(管理)-D3-11中层修改安排-批次现状不能为空",false);
      updateMidEditRespDto = fwAppOffStateClient.updateMidEdit(updateMidEditReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
      }
ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto_2 = null;
    ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto_1=new ImplementConcBhvThemeLockComComReqDto();
  implementConcBhvThemeLockComComReqDto_1.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1540304_1_61180
implementConcBhvThemeLockComComReqDto_1.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540305_1_61180
implementConcBhvThemeLockComComReqDto_1.setWhetherUnlockBulk("FALSE");//sourceId:1540307_1_61180
if(reqDto!=null){
      implementConcBhvThemeLockComComReqDto_1.setCommPrimaryKey(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:1540306_1_61180
      }

    /*D2执行并发行为主题解锁(公共)[8388]   */
    Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getPreventConcurrentLockingUnlocking(),"B3-11中层修改目标安排(管理)-D2执行并发行为主题解锁(公共)-防并发上锁or解锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getBehaviorThemeLockCode(),"B3-11中层修改目标安排(管理)-D2执行并发行为主题解锁(公共)-行为主题锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getCommPrimaryKey(),"B3-11中层修改目标安排(管理)-D2执行并发行为主题解锁(公共)-通用主键ID不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getWhetherUnlockBulk(),"B3-11中层修改目标安排(管理)-D2执行并发行为主题解锁(公共)-是否批量解锁不能为空",false);
      implementConcBhvThemeLockComComRespDto_2 = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



      }
else if((implementTopMidBasicCurrentBstepJudgeComRespDto!= null&&  implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() !=null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("FALSE")&&implementTopMidBasicGuideStepRoomRespDto!= null&&  implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue() !=null && implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue().equals("EXECUTE_TARGET_ARRANGE_ROOM"))){
       //elseif((D3执行高中基层当前步骤判断(公共).是否相等 等于 否 and D3执行中层导向步骤房间.进入步骤房间值 等于 执行目标安排房间))  61181

ImplementMidReturnSecondStepComRespDto implementMidReturnSecondStepComRespDto = null;
    if(implementTopMidBasicGuideStepRoomRespDto !=null){
    ImplementMidReturnSecondStepComReqDto implementMidReturnSecondStepComReqDto=new ImplementMidReturnSecondStepComReqDto();
  implementMidReturnSecondStepComReqDto.setUseTypeCode("USE_MID_ISSUE_OBJTIVE");//CUSTOM_CONVENTION//sourceId:1113305_1_61182
implementMidReturnSecondStepComReqDto.setBackMsgSendType("UN_SEND_MSG");//sourceId:1550939_1_61182
if(reqDto!=null){
      implementMidReturnSecondStepComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1052627_1_61182
implementMidReturnSecondStepComReqDto.setDeptTargetTaskBookId(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:1052628_1_61182
implementMidReturnSecondStepComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1052629_1_61182
implementMidReturnSecondStepComReqDto.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1052631_1_61182
implementMidReturnSecondStepComReqDto.setBatchCurrentStatus(reqDto.getBatchCurrentStatus());//SimpleFieldAssign//sourceId:1052633_1_61182
    }
if(implementTopMidBasicGuideStepRoomRespDto!=null){
      implementMidReturnSecondStepComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:1052630_1_61182
    }

    /*D3执行中层返回第二步(公共)[6330]   */
    Assert.isNull(implementMidReturnSecondStepComReqDto.getDeptId(),"B3-11中层修改目标安排(管理)-D3执行中层返回第二步(公共)-部门ID不能为空",false);
Assert.isNull(implementMidReturnSecondStepComReqDto.getDeptTargetTaskBookId(),"B3-11中层修改目标安排(管理)-D3执行中层返回第二步(公共)-部门目标任务书ID不能为空",false);
Assert.isNull(implementMidReturnSecondStepComReqDto.getEvaluationTemplateId(),"B3-11中层修改目标安排(管理)-D3执行中层返回第二步(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementMidReturnSecondStepComReqDto.getStepRoomValue(),"B3-11中层修改目标安排(管理)-D3执行中层返回第二步(公共)-进入步骤房间值不能为空",false);
Assert.isNull(implementMidReturnSecondStepComReqDto.getBatchCode(),"B3-11中层修改目标安排(管理)-D3执行中层返回第二步(公共)-批次标识不能为空",false);
Assert.isNull(implementMidReturnSecondStepComReqDto.getBatchCurrentStatus(),"B3-11中层修改目标安排(管理)-D3执行中层返回第二步(公共)-批次现状不能为空",false);
Assert.isNull(implementMidReturnSecondStepComReqDto.getUseTypeCode(),"B3-11中层修改目标安排(管理)-D3执行中层返回第二步(公共)-用途类型编码不能为空",false);
Assert.isNull(implementMidReturnSecondStepComReqDto.getBackMsgSendType(),"B3-11中层修改目标安排(管理)-D3执行中层返回第二步(公共)-回退消息发送类型不能为空",false);
      implementMidReturnSecondStepComRespDto = fwAppOffStateClient.implementMidReturnSecondStepCom(implementMidReturnSecondStepComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



    }
ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto_3 = null;
    ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto_2=new ImplementConcBhvThemeLockComComReqDto();
  implementConcBhvThemeLockComComReqDto_2.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1540304_1_61183
implementConcBhvThemeLockComComReqDto_2.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540305_1_61183
implementConcBhvThemeLockComComReqDto_2.setWhetherUnlockBulk("FALSE");//sourceId:1540307_1_61183
if(reqDto!=null){
      implementConcBhvThemeLockComComReqDto_2.setCommPrimaryKey(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:1540306_1_61183
    }

    /*D2执行并发行为主题解锁(公共)[8388]   */
    Assert.isNull(implementConcBhvThemeLockComComReqDto_2.getPreventConcurrentLockingUnlocking(),"B3-11中层修改目标安排(管理)-D2执行并发行为主题解锁(公共)-防并发上锁or解锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_2.getBehaviorThemeLockCode(),"B3-11中层修改目标安排(管理)-D2执行并发行为主题解锁(公共)-行为主题锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_2.getCommPrimaryKey(),"B3-11中层修改目标安排(管理)-D2执行并发行为主题解锁(公共)-通用主键ID不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_2.getWhetherUnlockBulk(),"B3-11中层修改目标安排(管理)-D2执行并发行为主题解锁(公共)-是否批量解锁不能为空",false);
      implementConcBhvThemeLockComComRespDto_3 = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;



    }
else if((implementTopMidBasicCurrentBstepJudgeComRespDto!= null&&  implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() !=null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("FALSE")&&implementTopMidBasicGuideStepRoomRespDto!= null&&  implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue() !=null && implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue().equals("LEAD_TARGET_ARRANGE_ROOM"))){
       //elseif((D3执行高中基层当前步骤判断(公共).是否相等 等于 否 and D3执行中层导向步骤房间.进入步骤房间值 等于 牵头目标安排房间))  61184

ImplementMidReturnFirstStepComRespDto implementMidReturnFirstStepComRespDto = null;
    if(implementTopMidBasicGuideStepRoomRespDto !=null){
    ImplementMidReturnFirstStepComReqDto implementMidReturnFirstStepComReqDto=new ImplementMidReturnFirstStepComReqDto();
  implementMidReturnFirstStepComReqDto.setUseTypeCode("USE_MID_ISSUE_OBJTIVE");//CUSTOM_CONVENTION//sourceId:1113306_1_61185
implementMidReturnFirstStepComReqDto.setBackMsgSendType("UN_SEND_MSG");//sourceId:1550942_1_61185
  if(reqDto!=null){
      implementMidReturnFirstStepComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1052640_1_61185
implementMidReturnFirstStepComReqDto.setDeptTargetTaskBookId(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:1052636_1_61185
implementMidReturnFirstStepComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1052637_1_61185
implementMidReturnFirstStepComReqDto.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1052639_1_61185
implementMidReturnFirstStepComReqDto.setBatchCurrentStatus(reqDto.getBatchCurrentStatus());//SimpleFieldAssign//sourceId:1052642_1_61185
    }
if(implementTopMidBasicGuideStepRoomRespDto!=null){
      implementMidReturnFirstStepComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:1052638_1_61185
    }

    /*D3执行中层返回第一步(公共)[3748]   */
    Assert.isNull(implementMidReturnFirstStepComReqDto.getDeptId(),"B3-11中层修改目标安排(管理)-D3执行中层返回第一步(公共)-部门ID不能为空",false);
Assert.isNull(implementMidReturnFirstStepComReqDto.getDeptTargetTaskBookId(),"B3-11中层修改目标安排(管理)-D3执行中层返回第一步(公共)-部门目标任务书ID不能为空",false);
Assert.isNull(implementMidReturnFirstStepComReqDto.getEvaluationTemplateId(),"B3-11中层修改目标安排(管理)-D3执行中层返回第一步(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementMidReturnFirstStepComReqDto.getStepRoomValue(),"B3-11中层修改目标安排(管理)-D3执行中层返回第一步(公共)-进入步骤房间值不能为空",false);
Assert.isNull(implementMidReturnFirstStepComReqDto.getBatchCode(),"B3-11中层修改目标安排(管理)-D3执行中层返回第一步(公共)-批次标识不能为空",false);
Assert.isNull(implementMidReturnFirstStepComReqDto.getBatchCurrentStatus(),"B3-11中层修改目标安排(管理)-D3执行中层返回第一步(公共)-批次现状不能为空",false);
Assert.isNull(implementMidReturnFirstStepComReqDto.getUseTypeCode(),"B3-11中层修改目标安排(管理)-D3执行中层返回第一步(公共)-用途类型编码不能为空",false);
Assert.isNull(implementMidReturnFirstStepComReqDto.getBackMsgSendType(),"B3-11中层修改目标安排(管理)-D3执行中层返回第一步(公共)-回退消息发送类型不能为空",false);
      implementMidReturnFirstStepComRespDto = fwAppOffStateClient.implementMidReturnFirstStepCom(implementMidReturnFirstStepComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto_4 = null;
    ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto_3=new ImplementConcBhvThemeLockComComReqDto();
  implementConcBhvThemeLockComComReqDto_3.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1540304_1_61186
implementConcBhvThemeLockComComReqDto_3.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540305_1_61186
implementConcBhvThemeLockComComReqDto_3.setWhetherUnlockBulk("FALSE");//sourceId:1540307_1_61186
if(reqDto!=null){
      implementConcBhvThemeLockComComReqDto_3.setCommPrimaryKey(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:1540306_1_61186
    }

    /*D2执行并发行为主题解锁(公共)[8388]   */
    Assert.isNull(implementConcBhvThemeLockComComReqDto_3.getPreventConcurrentLockingUnlocking(),"B3-11中层修改目标安排(管理)-D2执行并发行为主题解锁(公共)-防并发上锁or解锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_3.getBehaviorThemeLockCode(),"B3-11中层修改目标安排(管理)-D2执行并发行为主题解锁(公共)-行为主题锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_3.getCommPrimaryKey(),"B3-11中层修改目标安排(管理)-D2执行并发行为主题解锁(公共)-通用主键ID不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_3.getWhetherUnlockBulk(),"B3-11中层修改目标安排(管理)-D2执行并发行为主题解锁(公共)-是否批量解锁不能为空",false);
      implementConcBhvThemeLockComComRespDto_4 = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto_3).getData()/*vcase invoke 跨dubbo调用;*/;



    }
else if((implementTopMidBasicCurrentBstepJudgeComRespDto!= null&&  implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() !=null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("TRUE"))){
       //elseif(D3执行高中基层当前步骤判断(公共).是否相等 等于 是)  61187

//异常结束 61188
      throw new BizException("B10100289","对不起！当前房间已变化，请刷新页面~",false);
    }
      }
else if((implementConcBhvThemeLockComComRespDto!= null&&  implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() !=null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("CONCURRENT_LOCK_FAILURE"))){
       //elseif(D2执行上并发中层步骤变更锁(公共).防并发上锁情况 等于 并发上锁失败)  61189

//异常结束 61190
      throw new BizException("B10100288","操作过于频繁，请稍后再试~",false);
    }
BffUpdateMidEditRespDto retData = new BffUpdateMidEditRespDto();
  if(implementTopMidBasicGuideStepRoomRespDto_1!=null){
      retData.setStepNameCode(implementTopMidBasicGuideStepRoomRespDto_1.getStepNameCode());//SimpleFieldAssign//sourceId:1203778_1
    }
  

  
  
return retData;
  }
/**
   * B3-11基层修改目标安排(管理)[3061]
   * gen by moon at 10/24/2023, 3:33:43 AM
   */
    @Trace(operationName = "B3-11基层修改目标安排(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffUpdateGrootsEditRespDto updateGrootsEdit(BffUpdateGrootsEditReqDto reqDto){
      
       
       ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto_1 =null;
//virtualUsage D3执行高中基层导向步骤房间  51049
      ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto = null;
    ImplementTopMidBasicGuideStepRoomReqDto implementTopMidBasicGuideStepRoomReqDto=new ImplementTopMidBasicGuideStepRoomReqDto();
  implementTopMidBasicGuideStepRoomReqDto.setEditTargetArrange("1");//CUSTOM_CONVENTION//sourceId:1203674_1_51049
implementTopMidBasicGuideStepRoomReqDto.setBatchOperateScene("BASIC");//sourceId:1203675_1_51049

    /*D3执行高中基层导向步骤房间[7600]   */
    Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getEditTargetArrange(),"B3-11基层修改目标安排(管理)-D3执行高中基层导向步骤房间-修改目标安排不能为空",false);
Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getBatchOperateScene(),"B3-11基层修改目标安排(管理)-D3执行高中基层导向步骤房间-高/中/基层操作场景不能为空",false);
      implementTopMidBasicGuideStepRoomRespDto = fwAppEvaSystemClient.implementTopMidBasicGuideStepRoom(implementTopMidBasicGuideStepRoomReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      implementTopMidBasicGuideStepRoomRespDto_1 = implementTopMidBasicGuideStepRoomRespDto;
if((implementTopMidBasicGuideStepRoomRespDto!= null&& implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue() != null )) {
        //if(D3执行高中基层导向步骤房间.进入步骤房间值 值不等于空 )  51050

     UpdateGrootsEditRespDto updateGrootsEditRespDto = null;
    if(implementTopMidBasicGuideStepRoomRespDto !=null){
    UpdateGrootsEditReqDto updateGrootsEditReqDto=new UpdateGrootsEditReqDto();
  if(reqDto!=null){
      updateGrootsEditReqDto.setDeptOkrTargetId(reqDto.getDeptOkrTargetId());//SimpleFieldAssign//sourceId:856701_1_51051
updateGrootsEditReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:335443_1_51051
updateGrootsEditReqDto.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:856702_1_51051
updateGrootsEditReqDto.setBatchCurrentStatus(reqDto.getBatchCurrentStatus());//SimpleFieldAssign//sourceId:856703_1_51051
    }
if(implementTopMidBasicGuideStepRoomRespDto!=null){
      updateGrootsEditReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:340918_1_51051
    }
  
    /*D3-11基层修改安排[4618]   */
Assert.isNull(updateGrootsEditReqDto.getDeptOkrTargetId(),"B3-11基层修改目标安排(管理)-D3-11基层修改安排-部门OKR目标ID不能为空",false);
Assert.isNull(updateGrootsEditReqDto.getTargetId(),"B3-11基层修改目标安排(管理)-D3-11基层修改安排-冗余目标ID不能为空",false);
Assert.isNull(updateGrootsEditReqDto.getStepRoomValue(),"B3-11基层修改目标安排(管理)-D3-11基层修改安排-进入步骤房间值不能为空",false);
Assert.isNull(updateGrootsEditReqDto.getBatchCode(),"B3-11基层修改目标安排(管理)-D3-11基层修改安排-批次标识不能为空",false);
Assert.isNull(updateGrootsEditReqDto.getBatchCurrentStatus(),"B3-11基层修改目标安排(管理)-D3-11基层修改安排-批次现状不能为空",false);
      updateGrootsEditRespDto = fwAppOffStateClient.updateGrootsEdit(updateGrootsEditReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
           }
      }
BffUpdateGrootsEditRespDto retData = new BffUpdateGrootsEditRespDto();
  if(implementTopMidBasicGuideStepRoomRespDto_1!=null){
      retData.setStepNameCode(implementTopMidBasicGuideStepRoomRespDto_1.getStepNameCode());//SimpleFieldAssign//sourceId:1203676_1
    }
  

  
  
return retData;
  }
/**
   * B3-11更新目标内容父子状态(管理)[3781]
   * gen by moon at 12/26/2022, 5:05:42 PM
   */
    @Trace(operationName = "B3-11更新目标内容父子状态(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffRefreshTargetContentParentStateRespDto refreshTargetContentParentState(BffRefreshTargetContentParentStateReqDto reqDto){
      
       
       //步骤0: D3-11更新目标内容父子状态(公共) - refreshTargetContentParentStateCom
     RefreshTargetContentParentStateComRespDto refreshTargetContentParentStateComRespDto = null;
    RefreshTargetContentParentStateComReqDto refreshTargetContentParentStateComReqDto=new RefreshTargetContentParentStateComReqDto();
  if(reqDto!=null){
      refreshTargetContentParentStateComReqDto.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:373218_1
refreshTargetContentParentStateComReqDto.setTargetCategoryId(reqDto.getTargetCategoryId());//SimpleFieldAssign//sourceId:367624_1
refreshTargetContentParentStateComReqDto.setTargetObjList(reqDto.getTargetObjList());//list-field-assign//sourceId:367623_1
refreshTargetContentParentStateComReqDto.setParentObjectiveId(reqDto.getParentObjectiveId());//SimpleFieldAssign//sourceId:373219_1
refreshTargetContentParentStateComReqDto.setParentTargetCategoryId(reqDto.getParentTargetCategoryId());//SimpleFieldAssign//sourceId:373220_1
refreshTargetContentParentStateComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:367626_1
refreshTargetContentParentStateComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:406656_1
    }
  
    /*D3-11更新目标内容父子状态(公共)[4778]   */
    Assert.isNull(refreshTargetContentParentStateComReqDto.getObjectTypeCode(),"B3-11更新目标内容父子状态(管理)-D3-11更新目标内容父子状态(公共)-内容对象类型编码不能为空",false);
Assert.isNull(refreshTargetContentParentStateComReqDto.getEvaluationTemplateId(),"B3-11更新目标内容父子状态(管理)-D3-11更新目标内容父子状态(公共)-冗余评价模板ID不能为空",false);
      refreshTargetContentParentStateComRespDto = fwAppOffStateClient.refreshTargetContentParentStateCom(refreshTargetContentParentStateComReqDto).getData();
      
      
      
    
BffRefreshTargetContentParentStateRespDto retData = new BffRefreshTargetContentParentStateRespDto();
  
  

  
  
return retData;
  }
/**
   * B3-11查询目标内容父子状态本级完成情况(管理)[4004]
   * gen by moon at 10/8/2022, 3:10:19 AM
   */
    @Trace(operationName = "B3-11查询目标内容父子状态本级完成情况(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffQueryTargetContPresentAssistStatusSelfListRespDto queryTargetContPresentAssistStatusSelfList(BffQueryTargetContPresentAssistStatusSelfListReqDto reqDto){
      
       
       QueryTargetContPresentAssistStatusSelfListRespDto queryTargetContPresentAssistStatusSelfListRespDto_1 =null;
//步骤0: D3-11查询目标内容父子状态本级完成情况 - queryTargetContPresentAssistStatusSelfList
     QueryTargetContPresentAssistStatusSelfListRespDto queryTargetContPresentAssistStatusSelfListRespDto = null;
    QueryTargetContPresentAssistStatusSelfListReqDto queryTargetContPresentAssistStatusSelfListReqDto=new QueryTargetContPresentAssistStatusSelfListReqDto();
  if(reqDto!=null){
      queryTargetContPresentAssistStatusSelfListReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:369840_1
queryTargetContPresentAssistStatusSelfListReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:369841_1
queryTargetContPresentAssistStatusSelfListReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:369842_1
queryTargetContPresentAssistStatusSelfListReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:369843_1
    }
  
    /*D3-11查询目标内容父子状态本级完成情况[4005]   */
    Assert.isNull(queryTargetContPresentAssistStatusSelfListReqDto.getTargetCycleContentTypeCode(),"B3-11查询目标内容父子状态本级完成情况(管理)-D3-11查询目标内容父子状态本级完成情况-关联目标内容类型编码不能为空",false);
Assert.isNull(queryTargetContPresentAssistStatusSelfListReqDto.getTargetCycleContentId(),"B3-11查询目标内容父子状态本级完成情况(管理)-D3-11查询目标内容父子状态本级完成情况-关联目标内容ID不能为空",false);
Assert.isNull(queryTargetContPresentAssistStatusSelfListReqDto.getTargetId(),"B3-11查询目标内容父子状态本级完成情况(管理)-D3-11查询目标内容父子状态本级完成情况-冗余目标ID不能为空",false);
      queryTargetContPresentAssistStatusSelfListRespDto = fwAppOffStateClient.queryTargetContPresentAssistStatusSelfList(queryTargetContPresentAssistStatusSelfListReqDto).getData();
      
      
      queryTargetContPresentAssistStatusSelfListRespDto_1 = queryTargetContPresentAssistStatusSelfListRespDto;
    
BffQueryTargetContPresentAssistStatusSelfListRespDto retData = new BffQueryTargetContPresentAssistStatusSelfListRespDto();
  if(queryTargetContPresentAssistStatusSelfListRespDto_1!=null){
      retData.setAssistNodeStatusList(queryTargetContPresentAssistStatusSelfListRespDto_1.getAssistNodeStatusList().stream().map(item -> BeanUtil.toBean(item, BffAssistNodeStatusDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:369848_1
    }
  

  
  
return retData;
  }
/**
   * B3-11设完成中层检查项状态(管理)[3966]
   * gen by moon at 5/4/2023, 3:20:36 PM
   */
    @Trace(operationName = "B3-11设完成中层检查项状态(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffCompleteMidExecuteTargetCheckItemRespDto completeMidExecuteTargetCheckItem(BffCompleteMidExecuteTargetCheckItemReqDto reqDto){
      
       
       //步骤0: D3-11设完成中层执行目标安排检查项 - completeMidExecuteTargetCheckItem
     CompleteMidExecuteTargetCheckItemRespDto completeMidExecuteTargetCheckItemRespDto = null;
    CompleteMidExecuteTargetCheckItemReqDto completeMidExecuteTargetCheckItemReqDto=new CompleteMidExecuteTargetCheckItemReqDto();
  if(reqDto!=null){
      completeMidExecuteTargetCheckItemReqDto.setCheckItemCode(reqDto.getCheckItemCode());//SimpleFieldAssign//sourceId:881743_1
completeMidExecuteTargetCheckItemReqDto.setDeptTargetTaskBookId(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:881744_1
completeMidExecuteTargetCheckItemReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:881745_1
completeMidExecuteTargetCheckItemReqDto.setEvaTempBatchMgtOperationType(reqDto.getEvaTempBatchMgtOperationType());//SimpleFieldAssign//sourceId:883026_1
    }
  
    /*D3-11设完成中层执行目标安排检查项[3967]   */
Assert.isNull(completeMidExecuteTargetCheckItemReqDto.getCheckItemCode(),"B3-11设完成中层检查项状态(管理)-D3-11设完成中层执行目标安排检查项-检查项标识不能为空",false);
Assert.isNull(completeMidExecuteTargetCheckItemReqDto.getDeptTargetTaskBookId(),"B3-11设完成中层检查项状态(管理)-D3-11设完成中层执行目标安排检查项-部门目标任务书ID不能为空",false);
Assert.isNull(completeMidExecuteTargetCheckItemReqDto.getEvaluationTemplateId(),"B3-11设完成中层检查项状态(管理)-D3-11设完成中层执行目标安排检查项-冗余评价模板ID不能为空",false);
Assert.isNull(completeMidExecuteTargetCheckItemReqDto.getEvaTempBatchMgtOperationType(),"B3-11设完成中层检查项状态(管理)-D3-11设完成中层执行目标安排检查项-评价模板批次下管理操作类型不能为空",false);
      completeMidExecuteTargetCheckItemRespDto = fwAppOffStateClient.completeMidExecuteTargetCheckItem(completeMidExecuteTargetCheckItemReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
    
BffCompleteMidExecuteTargetCheckItemRespDto retData = new BffCompleteMidExecuteTargetCheckItemRespDto();
  
  

  
  
return retData;
  }
/**
   * B3-11取消完成中层检查项状态(管理)[3976]
   * gen by moon at 5/3/2023, 11:27:56 PM
   */
    @Trace(operationName = "B3-11取消完成中层检查项状态(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffCancelCompleteMidExecuteTargetCheckItemRespDto cancelCompleteMidExecuteTargetCheckItem(BffCancelCompleteMidExecuteTargetCheckItemReqDto reqDto){
      
       
       //步骤0: D3-11取消完成中层执行目标安排检查项 - cancelCompleteMidExecuteTargetCheckItem
     CancelCompleteMidExecuteTargetCheckItemRespDto cancelCompleteMidExecuteTargetCheckItemRespDto = null;
    CancelCompleteMidExecuteTargetCheckItemReqDto cancelCompleteMidExecuteTargetCheckItemReqDto=new CancelCompleteMidExecuteTargetCheckItemReqDto();
  if(reqDto!=null){
      cancelCompleteMidExecuteTargetCheckItemReqDto.setCheckItemCode(reqDto.getCheckItemCode());//SimpleFieldAssign//sourceId:880551_1
cancelCompleteMidExecuteTargetCheckItemReqDto.setDeptTargetTaskBookId(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:880435_1
cancelCompleteMidExecuteTargetCheckItemReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:334821_1
cancelCompleteMidExecuteTargetCheckItemReqDto.setEvaTempBatchMgtOperationType(reqDto.getEvaTempBatchMgtOperationType());//SimpleFieldAssign//sourceId:341285_1
    }
  
    /*D3-11取消完成中层执行目标安排检查项[3977]   */
    Assert.isNull(cancelCompleteMidExecuteTargetCheckItemReqDto.getCheckItemCode(),"B3-11取消完成中层检查项状态(管理)-D3-11取消完成中层执行目标安排检查项-检查项标识不能为空",false);
Assert.isNull(cancelCompleteMidExecuteTargetCheckItemReqDto.getDeptTargetTaskBookId(),"B3-11取消完成中层检查项状态(管理)-D3-11取消完成中层执行目标安排检查项-部门目标任务书ID不能为空",false);
Assert.isNull(cancelCompleteMidExecuteTargetCheckItemReqDto.getEvaluationTemplateId(),"B3-11取消完成中层检查项状态(管理)-D3-11取消完成中层执行目标安排检查项-冗余评价模板ID不能为空",false);
Assert.isNull(cancelCompleteMidExecuteTargetCheckItemReqDto.getEvaTempBatchMgtOperationType(),"B3-11取消完成中层检查项状态(管理)-D3-11取消完成中层执行目标安排检查项-评价模板批次下管理操作类型不能为空",false);
      cancelCompleteMidExecuteTargetCheckItemRespDto = fwAppOffStateClient.cancelCompleteMidExecuteTargetCheckItem(cancelCompleteMidExecuteTargetCheckItemReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
    
BffCancelCompleteMidExecuteTargetCheckItemRespDto retData = new BffCancelCompleteMidExecuteTargetCheckItemRespDto();
  
  

  
  
return retData;
  }
/**
   * B3-11设完成基层执行目标任务安排检查项(管理)[4678]
   * gen by moon at 11/8/2022, 5:43:54 AM
   */
    @Trace(operationName = "B3-11设完成基层执行目标任务安排检查项(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffCompleteBasicExecuteTargetCheckItemRespDto completeBasicExecuteTargetCheckItem(BffCompleteBasicExecuteTargetCheckItemReqDto reqDto){
      
       
       //步骤0: D3-11设完成基层执行目标任务安排检查项 - completeBasicExecuteTargetCheckItem
     CompleteBasicExecuteTargetCheckItemRespDto completeBasicExecuteTargetCheckItemRespDto = null;
    CompleteBasicExecuteTargetCheckItemReqDto completeBasicExecuteTargetCheckItemReqDto=new CompleteBasicExecuteTargetCheckItemReqDto();
  if(reqDto!=null){
      completeBasicExecuteTargetCheckItemReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:341391_1
completeBasicExecuteTargetCheckItemReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:341393_1
    }
  
    /*D3-11设完成基层执行目标任务安排检查项[4680]   */
    Assert.isNull(completeBasicExecuteTargetCheckItemReqDto.getTargetId(),"B3-11设完成基层执行目标任务安排检查项(管理)-D3-11设完成基层执行目标任务安排检查项-目标ID不能为空",false);
Assert.isNull(completeBasicExecuteTargetCheckItemReqDto.getDeptId(),"B3-11设完成基层执行目标任务安排检查项(管理)-D3-11设完成基层执行目标任务安排检查项-部门ID不能为空",false);
      completeBasicExecuteTargetCheckItemRespDto = fwAppOffStateClient.completeBasicExecuteTargetCheckItem(completeBasicExecuteTargetCheckItemReqDto).getData();
      
      
      
    
BffCompleteBasicExecuteTargetCheckItemRespDto retData = new BffCompleteBasicExecuteTargetCheckItemRespDto();
  
  

  
  
return retData;
  }
/**
   * B3-11取消完成基层执行目标任务安排检查项(管理)[4679]
   * gen by moon at 11/8/2022, 5:43:56 AM
   */
    @Trace(operationName = "B3-11取消完成基层执行目标任务安排检查项(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffCancelCompleteBasicExecuteTargetCheckItemRespDto cancelCompleteBasicExecuteTargetCheckItem(BffCancelCompleteBasicExecuteTargetCheckItemReqDto reqDto){
      
       
       //步骤0: D3-11取消完成基层执行目标任务安排检查项 - cancelCompleteBasicExecuteTargetCheckItem
     CancelCompleteBasicExecuteTargetCheckItemRespDto cancelCompleteBasicExecuteTargetCheckItemRespDto = null;
    CancelCompleteBasicExecuteTargetCheckItemReqDto cancelCompleteBasicExecuteTargetCheckItemReqDto=new CancelCompleteBasicExecuteTargetCheckItemReqDto();
  if(reqDto!=null){
      cancelCompleteBasicExecuteTargetCheckItemReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:341364_1
cancelCompleteBasicExecuteTargetCheckItemReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:341366_1
    }
  
    /*D3-11取消完成基层执行目标任务安排检查项[4681]   */
    Assert.isNull(cancelCompleteBasicExecuteTargetCheckItemReqDto.getTargetId(),"B3-11取消完成基层执行目标任务安排检查项(管理)-D3-11取消完成基层执行目标任务安排检查项-目标ID不能为空",false);
Assert.isNull(cancelCompleteBasicExecuteTargetCheckItemReqDto.getDeptId(),"B3-11取消完成基层执行目标任务安排检查项(管理)-D3-11取消完成基层执行目标任务安排检查项-部门ID不能为空",false);
      cancelCompleteBasicExecuteTargetCheckItemRespDto = fwAppOffStateClient.cancelCompleteBasicExecuteTargetCheckItem(cancelCompleteBasicExecuteTargetCheckItemReqDto).getData();
      
      
      
    
BffCancelCompleteBasicExecuteTargetCheckItemRespDto retData = new BffCancelCompleteBasicExecuteTargetCheckItemRespDto();
  
  

  
  
return retData;
  }
/**
   * B3查询目标内容融合仪表盘列表(管理)[4960]
   * gen by moon at 11/29/2022, 8:06:09 PM
   */
    @Trace(operationName = "B3查询目标内容融合仪表盘列表(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffQueryTargetFusionDashboardListRespDto queryTargetFusionDashboardList(BffQueryTargetFusionDashboardListReqDto reqDto){
      
       
       QueryCheckItemPanelListComRespDto queryCheckItemPanelListComRespDto_1 =null;
//步骤0: D3-11查询检查仪表盘列表(公共) - queryCheckItemPanelListCom
     QueryCheckItemPanelListComRespDto queryCheckItemPanelListComRespDto = null;
    QueryCheckItemPanelListComReqDto queryCheckItemPanelListComReqDto=new QueryCheckItemPanelListComReqDto();
  if(reqDto!=null){
      queryCheckItemPanelListComReqDto.setCheckObjectTypeId(reqDto.getCheckObjectTypeId());//SimpleFieldAssign//sourceId:383906_1
queryCheckItemPanelListComReqDto.setCheckObjectTypeCode(reqDto.getCheckObjectTypeCode());//SimpleFieldAssign//sourceId:383908_1
    }
  
    /*D3-11查询检查仪表盘列表(公共)[2716]   */
    Assert.isNull(queryCheckItemPanelListComReqDto.getCheckObjectTypeId(),"B3查询目标内容融合仪表盘列表(管理)-D3-11查询检查仪表盘列表(公共)-检查内容对象ID 不能为空",false);
Assert.isNull(queryCheckItemPanelListComReqDto.getCheckObjectTypeCode(),"B3查询目标内容融合仪表盘列表(管理)-D3-11查询检查仪表盘列表(公共)-检查内容对象类型编码不能为空",false);
      queryCheckItemPanelListComRespDto = fwAppOffStateClient.queryCheckItemPanelListCom(queryCheckItemPanelListComReqDto).getData();
      
      
      queryCheckItemPanelListComRespDto_1 = queryCheckItemPanelListComRespDto;
    
BffQueryTargetFusionDashboardListRespDto retData = new BffQueryTargetFusionDashboardListRespDto();
  if(queryCheckItemPanelListComRespDto_1!=null){
      retData.setTargetDashboardCompletionStatusList(queryCheckItemPanelListComRespDto_1.getTargetDashboardCompletionStatusList().stream().map(item -> BeanUtil.toBean(item, BffTargetDashboardCompletionStatusDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:430391_1
retData.setMolecule(queryCheckItemPanelListComRespDto_1.getMolecule());//SimpleFieldAssign//sourceId:429242_1
retData.setDenominator(queryCheckItemPanelListComRespDto_1.getDenominator());//SimpleFieldAssign//sourceId:429243_1
retData.setOutputNum(queryCheckItemPanelListComRespDto_1.getOutputNum());//SimpleFieldAssign//sourceId:429244_1
    }
  

  
  
return retData;
  }
/**
   * B2-9查询评价主题步骤列表(边界)[4999]
   * gen by moon at 10/24/2022, 4:32:03 AM
   */
    @Trace(operationName = "B2-9查询评价主题步骤列表(边界)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffQueryEvaThemeStepListBorderRespDto queryEvaThemeStepListBorder(BffQueryEvaThemeStepListBorderReqDto reqDto){
      
       
       QueryEvaThemeStepListRespDto queryEvaThemeStepListRespDto_1 =null;
//步骤0: D2-9查询评价主题步骤列表 - queryEvaThemeStepList
     QueryEvaThemeStepListRespDto queryEvaThemeStepListRespDto = null;
    QueryEvaThemeStepListReqDto queryEvaThemeStepListReqDto=new QueryEvaThemeStepListReqDto();
  
  
    /*D2-9查询评价主题步骤列表[5000]   */
    
      queryEvaThemeStepListRespDto = fwCompOffStateClient.queryEvaThemeStepList(queryEvaThemeStepListReqDto).getData();
      
      
      queryEvaThemeStepListRespDto_1 = queryEvaThemeStepListRespDto;
    
BffQueryEvaThemeStepListBorderRespDto retData = new BffQueryEvaThemeStepListBorderRespDto();
  if(queryEvaThemeStepListRespDto_1!=null){
      retData.setStepList(queryEvaThemeStepListRespDto_1.getStepList().stream().map(item -> BeanUtil.toBean(item, BffStepDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:388520_1
    }
  

  
  
return retData;
  }
/**
   * B3-13查询中层兄弟部门分工安排检查项完成情况列表(管理)[5034]
   * gen by moon at 10/30/2023, 3:32:10 PM
   */
    @Trace(operationName = "B3-13查询中层兄弟部门分工安排检查项完成情况列表(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffQueryMidBrotherDeptDivArrangeCheckItemStatusListRespDto queryMidBrotherDeptDivArrangeCheckItemStatusList(BffQueryMidBrotherDeptDivArrangeCheckItemStatusListReqDto reqDto){
      
       
       QueryMidBrotherDeptDivArrangeCheckItemStatusListRespDto queryMidBrotherDeptDivArrangeCheckItemStatusListRespDto_1 =null;
//步骤0: D3-13查询中层兄弟部门分工安排检查项完成情况列表 - queryMidBrotherDeptDivArrangeCheckItemStatusList
     QueryMidBrotherDeptDivArrangeCheckItemStatusListRespDto queryMidBrotherDeptDivArrangeCheckItemStatusListRespDto = null;
    QueryMidBrotherDeptDivArrangeCheckItemStatusListReqDto queryMidBrotherDeptDivArrangeCheckItemStatusListReqDto=new QueryMidBrotherDeptDivArrangeCheckItemStatusListReqDto();
  if(reqDto!=null){
      queryMidBrotherDeptDivArrangeCheckItemStatusListReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:408738_1
      queryMidBrotherDeptDivArrangeCheckItemStatusListReqDto.setCheckItemCode(reqDto.getCheckItemCode());//SimpleFieldAssign//sourceId:407127_1
queryMidBrotherDeptDivArrangeCheckItemStatusListReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:407753_1
queryMidBrotherDeptDivArrangeCheckItemStatusListReqDto.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1058668_1
queryMidBrotherDeptDivArrangeCheckItemStatusListReqDto.setBatchCurrentStatus(reqDto.getBatchCurrentStatus());//SimpleFieldAssign//sourceId:1136326_1
queryMidBrotherDeptDivArrangeCheckItemStatusListReqDto.setMgtType(reqDto.getMgtType());//SimpleFieldAssign//sourceId:1136327_1
queryMidBrotherDeptDivArrangeCheckItemStatusListReqDto.setTargetDivTierSet(reqDto.getTargetDivTierSet());//SimpleFieldAssign//sourceId:1213366_1
    }
  
    /*D3-13查询中层兄弟部门分工安排检查项完成情况列表[5036]   */
    Assert.isNull(queryMidBrotherDeptDivArrangeCheckItemStatusListReqDto.getDeptId(),"B3-13查询中层兄弟部门分工安排检查项完成情况列表(管理)-D3-13查询中层兄弟部门分工安排检查项完成情况列表-部门ID不能为空",false);
    Assert.isNull(queryMidBrotherDeptDivArrangeCheckItemStatusListReqDto.getCheckItemCode(),"B3-13查询中层兄弟部门分工安排检查项完成情况列表(管理)-D3-13查询中层兄弟部门分工安排检查项完成情况列表-检查项标识不能为空",false);
Assert.isNull(queryMidBrotherDeptDivArrangeCheckItemStatusListReqDto.getEvaluationTemplateId(),"B3-13查询中层兄弟部门分工安排检查项完成情况列表(管理)-D3-13查询中层兄弟部门分工安排检查项完成情况列表-冗余评价模板ID不能为空",false);
Assert.isNull(queryMidBrotherDeptDivArrangeCheckItemStatusListReqDto.getBatchCode(),"B3-13查询中层兄弟部门分工安排检查项完成情况列表(管理)-D3-13查询中层兄弟部门分工安排检查项完成情况列表-批次标识不能为空",false);
Assert.isNull(queryMidBrotherDeptDivArrangeCheckItemStatusListReqDto.getBatchCurrentStatus(),"B3-13查询中层兄弟部门分工安排检查项完成情况列表(管理)-D3-13查询中层兄弟部门分工安排检查项完成情况列表-批次现状不能为空",false);
Assert.isNull(queryMidBrotherDeptDivArrangeCheckItemStatusListReqDto.getMgtType(),"B3-13查询中层兄弟部门分工安排检查项完成情况列表(管理)-D3-13查询中层兄弟部门分工安排检查项完成情况列表-管理类型不能为空",false);
      queryMidBrotherDeptDivArrangeCheckItemStatusListRespDto = fwAppOffStateClient.queryMidBrotherDeptDivArrangeCheckItemStatusList(queryMidBrotherDeptDivArrangeCheckItemStatusListReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      queryMidBrotherDeptDivArrangeCheckItemStatusListRespDto_1 = queryMidBrotherDeptDivArrangeCheckItemStatusListRespDto;
    
BffQueryMidBrotherDeptDivArrangeCheckItemStatusListRespDto retData = new BffQueryMidBrotherDeptDivArrangeCheckItemStatusListRespDto();
  if(queryMidBrotherDeptDivArrangeCheckItemStatusListRespDto_1!=null){
      retData.setDeptTargetTaskBookIdList(queryMidBrotherDeptDivArrangeCheckItemStatusListRespDto_1.getDeptTargetTaskBookIdList().stream().map(item -> BeanUtil.toBean(item, BffDeptTargetTaskBookIdDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:407764_1
retData.setDoneCalcCount(queryMidBrotherDeptDivArrangeCheckItemStatusListRespDto_1.getDoneCalcCount());//SimpleFieldAssign//sourceId:1141150_1
retData.setAllCalcCount(queryMidBrotherDeptDivArrangeCheckItemStatusListRespDto_1.getAllCalcCount());//SimpleFieldAssign//sourceId:1141151_1
retData.setIsAllArrangeAccomplish(queryMidBrotherDeptDivArrangeCheckItemStatusListRespDto_1.getIsAllArrangeAccomplish());//SimpleFieldAssign//sourceId:1141152_1
    }
  

  
  
return retData;
  }
/**
   * B3-13查询部门目标任务书根节点检查项状态(管理)[5058]
   * gen by moon at 9/22/2023, 6:50:32 PM
   */
    @Trace(operationName = "B3-13查询部门目标任务书根节点检查项状态(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffQueryDeptTargetRootNodeCheckItemStatDetailRespDto queryDeptTargetRootNodeCheckItemStatDetail(BffQueryDeptTargetRootNodeCheckItemStatDetailReqDto reqDto){
      
       
       QueryDeptTargetRootNodeCheckItemStatDetailRespDto queryDeptTargetRootNodeCheckItemStatDetailRespDto_1 =null;
//步骤0: D3-13查询部门目标任务书根节点检查项状态 - queryDeptTargetRootNodeCheckItemStatDetail
     QueryDeptTargetRootNodeCheckItemStatDetailRespDto queryDeptTargetRootNodeCheckItemStatDetailRespDto = null;
        QueryDeptTargetRootNodeCheckItemStatDetailReqDto queryDeptTargetRootNodeCheckItemStatDetailReqDto=new QueryDeptTargetRootNodeCheckItemStatDetailReqDto();
  if(reqDto!=null){
      queryDeptTargetRootNodeCheckItemStatDetailReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:408152_1
queryDeptTargetRootNodeCheckItemStatDetailReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:408153_1
queryDeptTargetRootNodeCheckItemStatDetailReqDto.setCheckItemCode(reqDto.getCheckItemCode());//SimpleFieldAssign//sourceId:408154_1
queryDeptTargetRootNodeCheckItemStatDetailReqDto.setLevelNumber(reqDto.getLevelNumber());//SimpleFieldAssign//sourceId:482026_1
    }
  
    /*D3-13查询部门目标任务书根节点检查项状态[5059]   */
    Assert.isNull(queryDeptTargetRootNodeCheckItemStatDetailReqDto.getDeptId(),"B3-13查询部门目标任务书根节点检查项状态(管理)-D3-13查询部门目标任务书根节点检查项状态-部门ID不能为空",false);
Assert.isNull(queryDeptTargetRootNodeCheckItemStatDetailReqDto.getEvaluationTemplateId(),"B3-13查询部门目标任务书根节点检查项状态(管理)-D3-13查询部门目标任务书根节点检查项状态-冗余评价模板ID不能为空",false);
Assert.isNull(queryDeptTargetRootNodeCheckItemStatDetailReqDto.getCheckItemCode(),"B3-13查询部门目标任务书根节点检查项状态(管理)-D3-13查询部门目标任务书根节点检查项状态-检查项标识不能为空",false);
      queryDeptTargetRootNodeCheckItemStatDetailRespDto = fwAppOffStateClient.queryDeptTargetRootNodeCheckItemStatDetail(queryDeptTargetRootNodeCheckItemStatDetailReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      queryDeptTargetRootNodeCheckItemStatDetailRespDto_1 = queryDeptTargetRootNodeCheckItemStatDetailRespDto;
    
BffQueryDeptTargetRootNodeCheckItemStatDetailRespDto retData = new BffQueryDeptTargetRootNodeCheckItemStatDetailRespDto();
  if(queryDeptTargetRootNodeCheckItemStatDetailRespDto_1!=null){
retData.setCheckItemCode(queryDeptTargetRootNodeCheckItemStatDetailRespDto_1.getCheckItemCode());//SimpleFieldAssign//sourceId:408167_1
retData.setCheckItemName(queryDeptTargetRootNodeCheckItemStatDetailRespDto_1.getCheckItemName());//SimpleFieldAssign//sourceId:408168_1
retData.setIsComplete(queryDeptTargetRootNodeCheckItemStatDetailRespDto_1.getIsComplete());//SimpleFieldAssign//sourceId:628844_1
retData.setDeptId(queryDeptTargetRootNodeCheckItemStatDetailRespDto_1.getDeptId());//SimpleFieldAssign//sourceId:408170_1
retData.setDeptShortName(queryDeptTargetRootNodeCheckItemStatDetailRespDto_1.getDeptShortName());//SimpleFieldAssign//sourceId:408171_1
retData.setDeptLeaderIdCardName(queryDeptTargetRootNodeCheckItemStatDetailRespDto_1.getDeptLeaderIdCardName());//SimpleFieldAssign//sourceId:1128932_1
retData.setDeptLeaderNickName(queryDeptTargetRootNodeCheckItemStatDetailRespDto_1.getDeptLeaderNickName());//SimpleFieldAssign//sourceId:1128933_1
retData.setDirectorIdCardName(queryDeptTargetRootNodeCheckItemStatDetailRespDto_1.getDirectorIdCardName());//SimpleFieldAssign//sourceId:1132834_1
retData.setPartyAndYouthDirectorIdCardName(queryDeptTargetRootNodeCheckItemStatDetailRespDto_1.getPartyAndYouthDirectorIdCardName());//SimpleFieldAssign//sourceId:1132835_1
retData.setMoleculeValue(queryDeptTargetRootNodeCheckItemStatDetailRespDto_1.getMoleculeValue());//SimpleFieldAssign//sourceId:604046_1
retData.setDenominatorValue(queryDeptTargetRootNodeCheckItemStatDetailRespDto_1.getDenominatorValue());//SimpleFieldAssign//sourceId:604047_1
retData.setIsDivComplete(queryDeptTargetRootNodeCheckItemStatDetailRespDto_1.getIsDivComplete());//SimpleFieldAssign//sourceId:628845_1
    }
  

  
  
return retData;
  }
/**
   * B3-11修改高层目标检查项(管理)[2931]
   * gen by moon at 10/29/2022, 6:30:55 PM
   */
    @Trace(operationName = "B3-11修改高层目标检查项(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffUpdateTopTargetCheckItemStatusRespDto updateTopTargetCheckItemStatus(BffUpdateTopTargetCheckItemStatusReqDto reqDto){


       //步骤0: D3-11修改高层目标检查项(公共) - updateTopTargetCheckItemStatusCom
     UpdateTopTargetCheckItemStatusComRespDto updateTopTargetCheckItemStatusComRespDto = null;
    UpdateTopTargetCheckItemStatusComReqDto updateTopTargetCheckItemStatusComReqDto=new UpdateTopTargetCheckItemStatusComReqDto();
  updateTopTargetCheckItemStatusComReqDto.setEvaTempBatchMgtOperationType("MIXTURE_OPERATION");//sourceId:330007_1
if(reqDto!=null){
      updateTopTargetCheckItemStatusComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:218037_1
updateTopTargetCheckItemStatusComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:218038_1
updateTopTargetCheckItemStatusComReqDto.setCheckItemCode(reqDto.getCheckItemCode());//SimpleFieldAssign//sourceId:218039_1
updateTopTargetCheckItemStatusComReqDto.setIsComplete(reqDto.getIsComplete());//SimpleFieldAssign//sourceId:218040_1
    }

    /*D3-11修改高层目标检查项(公共)[4034]   */
    Assert.isNull(updateTopTargetCheckItemStatusComReqDto.getEvaTempBatchMgtOperationType(),"B3-11修改高层目标检查项(管理)-D3-11修改高层目标检查项(公共)-评价模板批次下管理操作类型不能为空",false);
Assert.isNull(updateTopTargetCheckItemStatusComReqDto.getTargetId(),"B3-11修改高层目标检查项(管理)-D3-11修改高层目标检查项(公共)-冗余目标ID不能为空",false);
Assert.isNull(updateTopTargetCheckItemStatusComReqDto.getEvaluationTemplateId(),"B3-11修改高层目标检查项(管理)-D3-11修改高层目标检查项(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(updateTopTargetCheckItemStatusComReqDto.getCheckItemCode(),"B3-11修改高层目标检查项(管理)-D3-11修改高层目标检查项(公共)-检查项标识不能为空",false);
      updateTopTargetCheckItemStatusComRespDto = fwAppOffStateClient.updateTopTargetCheckItemStatusCom(updateTopTargetCheckItemStatusComReqDto).getData();




BffUpdateTopTargetCheckItemStatusRespDto retData = new BffUpdateTopTargetCheckItemStatusRespDto();





return retData;
  }
/**
   * B3-13查询公共业务应用校验项状态(管理)[4620]
   * gen by moon at 11/9/2022, 9:13:19 PM
   */
    @Trace(operationName = "B3-13查询公共业务应用校验项状态(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffQueryComCheckItemStatDetailRespDto queryComCheckItemStatDetail(BffQueryComCheckItemStatDetailReqDto reqDto){
      
       
       QueryComCheckItemStatDetailRespDto queryComCheckItemStatDetailRespDto_1 =null;
//步骤0: D3-13查询公共业务应用校验项状态 - queryComCheckItemStatDetail
     QueryComCheckItemStatDetailRespDto queryComCheckItemStatDetailRespDto = null;
    QueryComCheckItemStatDetailReqDto queryComCheckItemStatDetailReqDto=new QueryComCheckItemStatDetailReqDto();
  if(reqDto!=null){
      queryComCheckItemStatDetailReqDto.setCheckItemCode(reqDto.getCheckItemCode());//SimpleFieldAssign//sourceId:335795_1
queryComCheckItemStatDetailReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:335796_1
queryComCheckItemStatDetailReqDto.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:335797_1
    }
  
    /*D3-13查询公共业务应用校验项状态[4621]   */
    Assert.isNull(queryComCheckItemStatDetailReqDto.getCheckItemCode(),"B3-13查询公共业务应用校验项状态(管理)-D3-13查询公共业务应用校验项状态-检查项标识不能为空",false);
Assert.isNull(queryComCheckItemStatDetailReqDto.getEntityId(),"B3-13查询公共业务应用校验项状态(管理)-D3-13查询公共业务应用校验项状态-内容对象实例ID不能为空",false);
Assert.isNull(queryComCheckItemStatDetailReqDto.getObjectTypeCode(),"B3-13查询公共业务应用校验项状态(管理)-D3-13查询公共业务应用校验项状态-内容对象类型编码不能为空",false);
      queryComCheckItemStatDetailRespDto = fwAppOffStateClient.queryComCheckItemStatDetail(queryComCheckItemStatDetailReqDto).getData();
      
      
      queryComCheckItemStatDetailRespDto_1 = queryComCheckItemStatDetailRespDto;
    
BffQueryComCheckItemStatDetailRespDto retData = new BffQueryComCheckItemStatDetailRespDto();
  if(queryComCheckItemStatDetailRespDto_1!=null){
      retData.setStatusCheckItemId(queryComCheckItemStatDetailRespDto_1.getStatusCheckItemId());//SimpleFieldAssign//sourceId:335804_1
retData.setIsComplete(queryComCheckItemStatDetailRespDto_1.getIsComplete());//SimpleFieldAssign//sourceId:335805_1
    }
  

  
  
return retData;
  }
/**
   * B3查询融合目标检查项父子状态列表(管理)[4961]
   * gen by moon at 6/10/2023, 1:13:30 AM
   */
    @Trace(operationName = "B3查询融合目标检查项父子状态列表(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffQueryFuseTargetCheckItemNodeStatusListRespDto queryFuseTargetCheckItemNodeStatusList(BffQueryFuseTargetCheckItemNodeStatusListReqDto reqDto){


       QueryFuseTargetCheckItemNodeStatusListRespDto queryFuseTargetCheckItemNodeStatusListRespDto_1 =null;
ImplementCheckItemRespDto implementCheckItemRespDto_1 =null;
//步骤0: D3查询融合目标检查项父子状态列表 - queryFuseTargetCheckItemNodeStatusList
     QueryFuseTargetCheckItemNodeStatusListRespDto queryFuseTargetCheckItemNodeStatusListRespDto = null;
    QueryFuseTargetCheckItemNodeStatusListReqDto queryFuseTargetCheckItemNodeStatusListReqDto=new QueryFuseTargetCheckItemNodeStatusListReqDto();
  if(reqDto!=null){
      queryFuseTargetCheckItemNodeStatusListReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:383968_1
    }

    /*D3查询融合目标检查项父子状态列表[4962]   */
    Assert.isNull(queryFuseTargetCheckItemNodeStatusListReqDto.getEntityId(),"B3查询融合目标检查项父子状态列表(管理)-D3查询融合目标检查项父子状态列表-目标ID不能为空",false);
      queryFuseTargetCheckItemNodeStatusListRespDto = fwAppOffStateClient.queryFuseTargetCheckItemNodeStatusList(queryFuseTargetCheckItemNodeStatusListReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryFuseTargetCheckItemNodeStatusListRespDto_1 = queryFuseTargetCheckItemNodeStatusListRespDto;

//步骤1: D3-11批量查询检查项 - batchQueryCheckItem
     BatchQueryCheckItemRespDto batchQueryCheckItemRespDto = null;
    if(queryFuseTargetCheckItemNodeStatusListRespDto !=null){
          BatchQueryCheckItemReqDto batchQueryCheckItemReqDto=new BatchQueryCheckItemReqDto();
  batchQueryCheckItemReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:383936_1
if(queryFuseTargetCheckItemNodeStatusListRespDto!= null&&  queryFuseTargetCheckItemNodeStatusListRespDto.getBizAppCheckItemStatList() !=null&& !CollectionUtil.isEmpty(queryFuseTargetCheckItemNodeStatusListRespDto.getBizAppCheckItemStatList())){
      batchQueryCheckItemReqDto.setCheckItemList(queryFuseTargetCheckItemNodeStatusListRespDto.getBizAppCheckItemStatList().stream().map(item->item.getCheckItemCode())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:383935_1
    }

    /*D3-11批量查询检查项[3978]   */
    Assert.isNull(batchQueryCheckItemReqDto.getSubjectLifeCycle(),"B3查询融合目标检查项父子状态列表(管理)-D3-11批量查询检查项-主体生命周期不能为空",false);
      batchQueryCheckItemRespDto = fwAppOffStateClient.batchQueryCheckItem(batchQueryCheckItemReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }

//步骤2: D3执行检查项 - implementCheckItem
     ImplementCheckItemRespDto implementCheckItemRespDto = null;
    if(queryFuseTargetCheckItemNodeStatusListRespDto !=null){
          ImplementCheckItemReqDto implementCheckItemReqDto=new ImplementCheckItemReqDto();
  if(queryFuseTargetCheckItemNodeStatusListRespDto!= null&&  queryFuseTargetCheckItemNodeStatusListRespDto.getBizAppCheckItemStatList() !=null&& !CollectionUtil.isEmpty(queryFuseTargetCheckItemNodeStatusListRespDto.getBizAppCheckItemStatList())){
      implementCheckItemReqDto.setBizAppCheckItemStatList(queryFuseTargetCheckItemNodeStatusListRespDto.getBizAppCheckItemStatList().stream().map(item -> BeanUtil.toBean(item, BizAppCheckItemStatDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:384219_1
    }
if(batchQueryCheckItemRespDto!= null&&  batchQueryCheckItemRespDto.getCheckItemList() !=null&& !CollectionUtil.isEmpty(batchQueryCheckItemRespDto.getCheckItemList())){
      implementCheckItemReqDto.setCheckItemFusionMainContentList(batchQueryCheckItemRespDto.getCheckItemList().stream().map(item -> BeanUtil.toBean(item, CheckItemFusionMainContentDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:384218_1
    }

    /*D3执行检查项[4970]   */

      implementCheckItemRespDto = fwAppOffStateClient.implementCheckItem(implementCheckItemReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      implementCheckItemRespDto_1 = implementCheckItemRespDto;
           }

BffQueryFuseTargetCheckItemNodeStatusListRespDto retData = new BffQueryFuseTargetCheckItemNodeStatusListRespDto();
  if(queryFuseTargetCheckItemNodeStatusListRespDto_1!=null){
      retData.setTargetCheckItemStatusList(queryFuseTargetCheckItemNodeStatusListRespDto_1.getSetConstructionTaskList().stream().map(item -> BeanUtil.toBean(item, BffTargetCheckItemStatusDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:384017_1
retData.setComFloatField1(queryFuseTargetCheckItemNodeStatusListRespDto_1.getComFloatField1());//SimpleFieldAssign//sourceId:545420_1
retData.setComFloatField2(queryFuseTargetCheckItemNodeStatusListRespDto_1.getComFloatField2());//SimpleFieldAssign//sourceId:545421_1
retData.setIsComplete(queryFuseTargetCheckItemNodeStatusListRespDto_1.getIsComplete());//SimpleFieldAssign//sourceId:545422_1
retData.setTargetIsComplete(queryFuseTargetCheckItemNodeStatusListRespDto_1.getTargetIsComplete());//SimpleFieldAssign//sourceId:1028558_1
retData.setSetCompleteStatus(queryFuseTargetCheckItemNodeStatusListRespDto_1.getSetCompleteStatus());//SimpleFieldAssign//sourceId:552082_1
    }
if(implementCheckItemRespDto_1!=null){
      retData.setBizAppCheckItemStatList(implementCheckItemRespDto_1.getBizAppCheckItemStatList().stream().map(item -> BeanUtil.toBean(item, BffBizAppCheckItemStatDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:523964_1
    }




return retData;
  }
/**
   * B3-13查询基层执行目标任务安排检查项(管理)[4620]
   * gen by moon at 9/22/2023, 6:50:28 PM
   */
    @Trace(operationName = "B3-13查询基层执行目标任务安排检查项(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffQueryBasicExecuteTargetCheckItemDetailRespDto queryBasicExecuteTargetCheckItemDetail(BffQueryBasicExecuteTargetCheckItemDetailReqDto reqDto){
      
       
       QueryGrootsTargetTaskDivArrangeStatusDetailRespDto queryGrootsTargetTaskDivArrangeStatusDetailRespDto_1 =null;
//步骤0: D3-13查询基层目标任务分工安排状态详情 - queryGrootsTargetTaskDivArrangeStatusDetail
     QueryGrootsTargetTaskDivArrangeStatusDetailRespDto queryGrootsTargetTaskDivArrangeStatusDetailRespDto = null;
    QueryGrootsTargetTaskDivArrangeStatusDetailReqDto queryGrootsTargetTaskDivArrangeStatusDetailReqDto=new QueryGrootsTargetTaskDivArrangeStatusDetailReqDto();
  queryGrootsTargetTaskDivArrangeStatusDetailReqDto.setCheckItemCode("PERFORM_TARGET_TASK_ARRANGE_CHECK_ITEM");//CUSTOM_CONVENTION//sourceId:585909_1
if(reqDto!=null){
      queryGrootsTargetTaskDivArrangeStatusDetailReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:585908_1
    }
  
    /*D3-13查询基层目标任务分工安排状态详情[4621]   */
    Assert.isNull(queryGrootsTargetTaskDivArrangeStatusDetailReqDto.getEvaObjTargetCycleId(),"B3-13查询基层执行目标任务安排检查项(管理)-D3-13查询基层目标任务分工安排状态详情-被评对象目标周期ID不能为空",false);
Assert.isNull(queryGrootsTargetTaskDivArrangeStatusDetailReqDto.getCheckItemCode(),"B3-13查询基层执行目标任务安排检查项(管理)-D3-13查询基层目标任务分工安排状态详情-检查项标识不能为空",false);
      queryGrootsTargetTaskDivArrangeStatusDetailRespDto = fwAppOffStateClient.queryGrootsTargetTaskDivArrangeStatusDetail(queryGrootsTargetTaskDivArrangeStatusDetailReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      queryGrootsTargetTaskDivArrangeStatusDetailRespDto_1 = queryGrootsTargetTaskDivArrangeStatusDetailRespDto;
    
BffQueryBasicExecuteTargetCheckItemDetailRespDto retData = new BffQueryBasicExecuteTargetCheckItemDetailRespDto();
  if(queryGrootsTargetTaskDivArrangeStatusDetailRespDto_1!=null){
      retData.setCheckItemCode(queryGrootsTargetTaskDivArrangeStatusDetailRespDto_1.getCheckItemCode());//SimpleFieldAssign//sourceId:585913_1
retData.setCheckItemName(queryGrootsTargetTaskDivArrangeStatusDetailRespDto_1.getCheckItemName());//SimpleFieldAssign//sourceId:429384_1
retData.setIsComplete(queryGrootsTargetTaskDivArrangeStatusDetailRespDto_1.getIsComplete());//SimpleFieldAssign//sourceId:628840_1
retData.setDeptId(queryGrootsTargetTaskDivArrangeStatusDetailRespDto_1.getDeptId());//SimpleFieldAssign//sourceId:585919_1
retData.setDeptShortName(queryGrootsTargetTaskDivArrangeStatusDetailRespDto_1.getDeptShortName());//SimpleFieldAssign//sourceId:429385_1
retData.setDeptLeaderIdCardName(queryGrootsTargetTaskDivArrangeStatusDetailRespDto_1.getDeptLeaderIdCardName());//SimpleFieldAssign//sourceId:1128960_1
retData.setDeptLeaderNickName(queryGrootsTargetTaskDivArrangeStatusDetailRespDto_1.getDeptLeaderNickName());//SimpleFieldAssign//sourceId:1128961_1
retData.setDirectorIdCardName(queryGrootsTargetTaskDivArrangeStatusDetailRespDto_1.getDirectorIdCardName());//SimpleFieldAssign//sourceId:1132840_1
retData.setPartyAndYouthDirectorIdCardName(queryGrootsTargetTaskDivArrangeStatusDetailRespDto_1.getPartyAndYouthDirectorIdCardName());//SimpleFieldAssign//sourceId:1132841_1
retData.setMoleculeValue(queryGrootsTargetTaskDivArrangeStatusDetailRespDto_1.getMoleculeValue());//SimpleFieldAssign//sourceId:604079_1
retData.setDenominatorValue(queryGrootsTargetTaskDivArrangeStatusDetailRespDto_1.getDenominatorValue());//SimpleFieldAssign//sourceId:604080_1
retData.setIsDivComplete(queryGrootsTargetTaskDivArrangeStatusDetailRespDto_1.getIsDivComplete());//SimpleFieldAssign//sourceId:628841_1
    }
  

  
  
return retData;
  }
/**
   * B3-11查询部门安排进度(管理)[5397]
   * gen by moon at 12/5/2022, 5:37:59 PM
   */
    @Trace(operationName = "B3-11查询部门安排进度(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffQueryDeptArrangeScheduleDetailRespDto queryDeptArrangeScheduleDetail(BffQueryDeptArrangeScheduleDetailReqDto reqDto){
      
       
       QueryDeptArrangeScheduleDetailComRespDto queryDeptArrangeScheduleDetailComRespDto_1 =null;
//步骤0: D3-11查询部门安排进度详情(公共) - queryDeptArrangeScheduleDetailCom
     QueryDeptArrangeScheduleDetailComRespDto queryDeptArrangeScheduleDetailComRespDto = null;
    QueryDeptArrangeScheduleDetailComReqDto queryDeptArrangeScheduleDetailComReqDto=new QueryDeptArrangeScheduleDetailComReqDto();
  if(reqDto!=null){
      queryDeptArrangeScheduleDetailComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:487588_1
queryDeptArrangeScheduleDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:487589_1
    }
  
    /*D3-11查询部门安排进度详情(公共)[5398]   */
    Assert.isNull(queryDeptArrangeScheduleDetailComReqDto.getDeptId(),"B3-11查询部门安排进度(管理)-D3-11查询部门安排进度详情(公共)-部门ID不能为空",false);
Assert.isNull(queryDeptArrangeScheduleDetailComReqDto.getEvaluationTemplateId(),"B3-11查询部门安排进度(管理)-D3-11查询部门安排进度详情(公共)-冗余评价模板ID不能为空",false);
      queryDeptArrangeScheduleDetailComRespDto = fwAppOffStateClient.queryDeptArrangeScheduleDetailCom(queryDeptArrangeScheduleDetailComReqDto).getData();
      
      
      queryDeptArrangeScheduleDetailComRespDto_1 = queryDeptArrangeScheduleDetailComRespDto;
    
BffQueryDeptArrangeScheduleDetailRespDto retData = new BffQueryDeptArrangeScheduleDetailRespDto();
  if(queryDeptArrangeScheduleDetailComRespDto_1!=null){
      retData.setMoleculeValue(queryDeptArrangeScheduleDetailComRespDto_1.getMoleculeValue());//SimpleFieldAssign//sourceId:487596_1
retData.setDenominatorValue(queryDeptArrangeScheduleDetailComRespDto_1.getDenominatorValue());//SimpleFieldAssign//sourceId:487597_1
retData.setIsComplete(queryDeptArrangeScheduleDetailComRespDto_1.getIsComplete());//SimpleFieldAssign//sourceId:487598_1
    }
  

  
  
return retData;
  }
/**
   * B3查询目标内容检查项状态列表[5517]
   * gen by moon at 12/25/2022, 7:28:08 PM
   */
    @Trace(operationName = "B3查询目标内容检查项状态列表")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffQueryTargetContCheckItemStateListRespDto queryTargetContCheckItemStateList(BffQueryTargetContCheckItemStateListReqDto reqDto){
      
       
       QueryTargetContCheckItemStateListRespDto queryTargetContCheckItemStateListRespDto_1 =null;
//步骤0: D3查询目标内容检查项状态列表 - queryTargetContCheckItemStateList
     QueryTargetContCheckItemStateListRespDto queryTargetContCheckItemStateListRespDto = null;
    QueryTargetContCheckItemStateListReqDto queryTargetContCheckItemStateListReqDto=new QueryTargetContCheckItemStateListReqDto();
  if(reqDto!=null){
      queryTargetContCheckItemStateListReqDto.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:544158_1
queryTargetContCheckItemStateListReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:544159_1
    }
  
    /*D3查询目标内容检查项状态列表[5516]   */
    Assert.isNull(queryTargetContCheckItemStateListReqDto.getObjectTypeCode(),"B3查询目标内容检查项状态列表-D3查询目标内容检查项状态列表-内容对象类型编码不能为空",false);
Assert.isNull(queryTargetContCheckItemStateListReqDto.getEntityId(),"B3查询目标内容检查项状态列表-D3查询目标内容检查项状态列表-内容对象实例ID不能为空",false);
      queryTargetContCheckItemStateListRespDto = fwAppOffStateClient.queryTargetContCheckItemStateList(queryTargetContCheckItemStateListReqDto).getData();
      
      
      queryTargetContCheckItemStateListRespDto_1 = queryTargetContCheckItemStateListRespDto;
    
BffQueryTargetContCheckItemStateListRespDto retData = new BffQueryTargetContCheckItemStateListRespDto();
  if(queryTargetContCheckItemStateListRespDto_1!=null){
      retData.setTargetContCheckItemStateList(queryTargetContCheckItemStateListRespDto_1.getTargetContCheckItemStateList().stream().map(item -> BeanUtil.toBean(item, BffTargetContCheckItemStateDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:544163_1
    }
  

  
  
return retData;
  }
/**
   * B3执行周期校验检查项更新(管理)[6035]
   * gen by moon at 7/14/2023, 11:02:17 AM
   */
    @Trace(operationName = "B3执行周期校验检查项更新(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffImplementCycleVerifyCheckItemUpdateRespDto implementCycleVerifyCheckItemUpdate(BffImplementCycleVerifyCheckItemUpdateReqDto reqDto){


       ImplementExecuteProgressOperationJudgeComRespDto implementExecuteProgressOperationJudgeComRespDto_1 =null;
//virtualUsage D3执行进度运行判断(公共)  47590
      ImplementExecuteProgressOperationJudgeComRespDto implementExecuteProgressOperationJudgeComRespDto = null;
    ImplementExecuteProgressOperationJudgeComReqDto implementExecuteProgressOperationJudgeComReqDto=new ImplementExecuteProgressOperationJudgeComReqDto();
  implementExecuteProgressOperationJudgeComReqDto.setUseTypeCode("USE_CYCLE_CHECK");//CUSTOM_CONVENTION//sourceId:1086286_1_47590
if(reqDto!=null){
      implementExecuteProgressOperationJudgeComReqDto.setObjectId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1086285_1_47590
implementExecuteProgressOperationJudgeComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1086287_1_47590
    }

    /*D3执行进度运行判断(公共)[7243]   */
    Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getObjectId(),"B3执行周期校验检查项更新(管理)-D3执行进度运行判断(公共)-归属对象内容ID不能为空",false);
Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getUseTypeCode(),"B3执行周期校验检查项更新(管理)-D3执行进度运行判断(公共)-用途类型编码不能为空",false);
Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getThemeContentId(),"B3执行周期校验检查项更新(管理)-D3执行进度运行判断(公共)-主题内容ID不能为空",false);
      implementExecuteProgressOperationJudgeComRespDto = fwAppExecuteProgressClient.implementExecuteProgressOperationJudgeCom(implementExecuteProgressOperationJudgeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      implementExecuteProgressOperationJudgeComRespDto_1 = implementExecuteProgressOperationJudgeComRespDto;
if((implementExecuteProgressOperationJudgeComRespDto!= null&& implementExecuteProgressOperationJudgeComRespDto.getCustomField() == null )) {
        //if(D3执行进度运行判断(公共).操作过于频繁，请稍后再试文案故事 值等于空 )  47591

     ImplementCycleVerifyCheckItemUpdateRespDto implementCycleVerifyCheckItemUpdateRespDto = null;
    ImplementCycleVerifyCheckItemUpdateReqDto implementCycleVerifyCheckItemUpdateReqDto=new ImplementCycleVerifyCheckItemUpdateReqDto();
  if(reqDto!=null){
      implementCycleVerifyCheckItemUpdateReqDto.setEvaObjTargetCycleCode(reqDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:731099_1_47592
implementCycleVerifyCheckItemUpdateReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:731093_1_47592
implementCycleVerifyCheckItemUpdateReqDto.setEvaObjTableTypeCode(reqDto.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:731094_1_47592
implementCycleVerifyCheckItemUpdateReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:731095_1_47592
implementCycleVerifyCheckItemUpdateReqDto.setTreeTypeCode(reqDto.getTreeTypeCode());//SimpleFieldAssign//sourceId:731096_1_47592
implementCycleVerifyCheckItemUpdateReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:731097_1_47592
implementCycleVerifyCheckItemUpdateReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:731098_1_47592
implementCycleVerifyCheckItemUpdateReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:731092_1_47592
implementCycleVerifyCheckItemUpdateReqDto.setBatchOperateScene(reqDto.getBatchOperateScene());//SimpleFieldAssign//sourceId:1036924_1_47592
    }

    /*D3执行周期校验检查项更新[6021]   */
    Assert.isNull(implementCycleVerifyCheckItemUpdateReqDto.getEvaObjTargetCycleCode(),"B3执行周期校验检查项更新(管理)-D3执行周期校验检查项更新-被评对象目标周期标识不能为空",false);
Assert.isNull(implementCycleVerifyCheckItemUpdateReqDto.getEvaObjEntityId(),"B3执行周期校验检查项更新(管理)-D3执行周期校验检查项更新-被评对象内容表主键ID不能为空",false);
Assert.isNull(implementCycleVerifyCheckItemUpdateReqDto.getEvaObjTableTypeCode(),"B3执行周期校验检查项更新(管理)-D3执行周期校验检查项更新-被评对象内容表类型编码不能为空",false);
Assert.isNull(implementCycleVerifyCheckItemUpdateReqDto.getEvaObjTypeCode(),"B3执行周期校验检查项更新(管理)-D3执行周期校验检查项更新-被评对象类型编码不能为空",false);
Assert.isNull(implementCycleVerifyCheckItemUpdateReqDto.getTreeTypeCode(),"B3执行周期校验检查项更新(管理)-D3执行周期校验检查项更新-树类型编码不能为空",false);
Assert.isNull(implementCycleVerifyCheckItemUpdateReqDto.getTargetCycleContentTypeCode(),"B3执行周期校验检查项更新(管理)-D3执行周期校验检查项更新-关联目标内容类型编码不能为空",false);
Assert.isNull(implementCycleVerifyCheckItemUpdateReqDto.getTargetCycleContentId(),"B3执行周期校验检查项更新(管理)-D3执行周期校验检查项更新-关联目标内容ID不能为空",false);
Assert.isNull(implementCycleVerifyCheckItemUpdateReqDto.getEvaluationTemplateId(),"B3执行周期校验检查项更新(管理)-D3执行周期校验检查项更新-冗余评价模板ID不能为空",false);
Assert.isNull(implementCycleVerifyCheckItemUpdateReqDto.getBatchOperateScene(),"B3执行周期校验检查项更新(管理)-D3执行周期校验检查项更新-高/中/基层操作场景不能为空",false);
      implementCycleVerifyCheckItemUpdateRespDto = fwAppOffStateClient.implementCycleVerifyCheckItemUpdate(implementCycleVerifyCheckItemUpdateReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



      }
BffImplementCycleVerifyCheckItemUpdateRespDto retData = new BffImplementCycleVerifyCheckItemUpdateRespDto();
  if(implementExecuteProgressOperationJudgeComRespDto_1!=null){
      retData.setCustomField(implementExecuteProgressOperationJudgeComRespDto_1.getCustomField());//SimpleFieldAssign//sourceId:1086289_1
    }




return retData;
  }
/**
   * B3执行强托底更新目标分类祖先父子状态等(管理)[6036]
   * gen by moon at 3/6/2023, 10:17:30 AM
   */
    @Trace(operationName = "B3执行强托底更新目标分类祖先父子状态等(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffImplementForceTorrUpdateCategoryAncestorNodeStatusETCRespDto implementForceTorrUpdateCategoryAncestorNodeStatusETC(BffImplementForceTorrUpdateCategoryAncestorNodeStatusETCReqDto reqDto){


       //步骤0: D3执行补偿强托底更新祖先父子状态等 - implementCompensateTorrUpdateAncestorNodeStatusEtc
     ImplementCompensateTorrUpdateAncestorNodeStatusEtcRespDto implementCompensateTorrUpdateAncestorNodeStatusEtcRespDto = null;
    ImplementCompensateTorrUpdateAncestorNodeStatusEtcReqDto implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto=new ImplementCompensateTorrUpdateAncestorNodeStatusEtcReqDto();
  if(reqDto!=null){
      implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:731108_1
implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:731109_1
implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:731110_1
    }

    /*D3执行补偿强托底更新祖先父子状态等[6026]   */
    Assert.isNull(implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto.getTableTypeCode(),"B3执行强托底更新目标分类祖先父子状态等(管理)-D3执行补偿强托底更新祖先父子状态等-冗余内容表类型编码不能为空",false);
Assert.isNull(implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto.getEntityId(),"B3执行强托底更新目标分类祖先父子状态等(管理)-D3执行补偿强托底更新祖先父子状态等-冗余内容表主键ID不能为空",false);
Assert.isNull(implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto.getEvaluationTemplateId(),"B3执行强托底更新目标分类祖先父子状态等(管理)-D3执行补偿强托底更新祖先父子状态等-冗余评价模板ID不能为空",false);
      implementCompensateTorrUpdateAncestorNodeStatusEtcRespDto = fwAppOffStateClient.implementCompensateTorrUpdateAncestorNodeStatusEtc(implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto).getData();




BffImplementForceTorrUpdateCategoryAncestorNodeStatusETCRespDto retData = new BffImplementForceTorrUpdateCategoryAncestorNodeStatusETCRespDto();





return retData;
  }
/**
   * B3执行目标校验检查项更新(管理)[6037]
   * gen by moon at 7/14/2023, 11:02:20 AM
   */
    @Trace(operationName = "B3执行目标校验检查项更新(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffImplementTargetValueVerifyCheckItemUpdateRespDto implementTargetValueVerifyCheckItemUpdate(BffImplementTargetValueVerifyCheckItemUpdateReqDto reqDto){


       ImplementExecuteProgressOperationJudgeComRespDto implementExecuteProgressOperationJudgeComRespDto_1 =null;
//virtualUsage D3执行进度运行判断(公共)  47597
      ImplementExecuteProgressOperationJudgeComRespDto implementExecuteProgressOperationJudgeComRespDto = null;
    ImplementExecuteProgressOperationJudgeComReqDto implementExecuteProgressOperationJudgeComReqDto=new ImplementExecuteProgressOperationJudgeComReqDto();
  implementExecuteProgressOperationJudgeComReqDto.setUseTypeCode("USE_TARGET_VALUE_CHECK");//CUSTOM_CONVENTION//sourceId:1086296_1_47597
if(reqDto!=null){
      implementExecuteProgressOperationJudgeComReqDto.setObjectId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1086295_1_47597
implementExecuteProgressOperationJudgeComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1086297_1_47597
    }

    /*D3执行进度运行判断(公共)[7243]   */
    Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getObjectId(),"B3执行目标校验检查项更新(管理)-D3执行进度运行判断(公共)-归属对象内容ID不能为空",false);
Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getUseTypeCode(),"B3执行目标校验检查项更新(管理)-D3执行进度运行判断(公共)-用途类型编码不能为空",false);
Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getThemeContentId(),"B3执行目标校验检查项更新(管理)-D3执行进度运行判断(公共)-主题内容ID不能为空",false);
      implementExecuteProgressOperationJudgeComRespDto = fwAppExecuteProgressClient.implementExecuteProgressOperationJudgeCom(implementExecuteProgressOperationJudgeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      implementExecuteProgressOperationJudgeComRespDto_1 = implementExecuteProgressOperationJudgeComRespDto;
if((implementExecuteProgressOperationJudgeComRespDto!= null&& implementExecuteProgressOperationJudgeComRespDto.getCustomField() == null )) {
        //if(D3执行进度运行判断(公共).操作过于频繁，请稍后再试文案故事 值等于空 )  47598

     ImplementTargetValueVerifyCheckItemUpdateRespDto implementTargetValueVerifyCheckItemUpdateRespDto = null;
    ImplementTargetValueVerifyCheckItemUpdateReqDto implementTargetValueVerifyCheckItemUpdateReqDto=new ImplementTargetValueVerifyCheckItemUpdateReqDto();
  if(reqDto!=null){
      implementTargetValueVerifyCheckItemUpdateReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:731169_1_47599
implementTargetValueVerifyCheckItemUpdateReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:731170_1_47599
implementTargetValueVerifyCheckItemUpdateReqDto.setBatchOperateScene(reqDto.getBatchOperateScene());//SimpleFieldAssign//sourceId:1037022_1_47599
    }

    /*D3执行目标校验检查项更新[6022]   */
    Assert.isNull(implementTargetValueVerifyCheckItemUpdateReqDto.getEntityId(),"B3执行目标校验检查项更新(管理)-D3执行目标校验检查项更新-冗余内容表主键ID不能为空",false);
Assert.isNull(implementTargetValueVerifyCheckItemUpdateReqDto.getEvaluationTemplateId(),"B3执行目标校验检查项更新(管理)-D3执行目标校验检查项更新-冗余评价模板ID不能为空",false);
Assert.isNull(implementTargetValueVerifyCheckItemUpdateReqDto.getBatchOperateScene(),"B3执行目标校验检查项更新(管理)-D3执行目标校验检查项更新-高/中/基层操作场景不能为空",false);
      implementTargetValueVerifyCheckItemUpdateRespDto = fwAppOffStateClient.implementTargetValueVerifyCheckItemUpdate(implementTargetValueVerifyCheckItemUpdateReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



      }
BffImplementTargetValueVerifyCheckItemUpdateRespDto retData = new BffImplementTargetValueVerifyCheckItemUpdateRespDto();
  if(implementExecuteProgressOperationJudgeComRespDto_1!=null){
      retData.setCustomField(implementExecuteProgressOperationJudgeComRespDto_1.getCustomField());//SimpleFieldAssign//sourceId:1086299_1
    }




return retData;
  }
/**
   * B3执行强托底更新目标内容祖先父子状态等(管理)[6036]
   * gen by moon at 3/26/2023, 8:00:38 PM
   */
    @Trace(operationName = "B3执行强托底更新目标内容祖先父子状态等(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffImplementForceTorrUpdateTargetContAncestorNodeStatusEtcRespDto implementForceTorrUpdateTargetContAncestorNodeStatusEtc(BffImplementForceTorrUpdateTargetContAncestorNodeStatusEtcReqDto reqDto){


       //步骤0: D3执行补偿强托底更新祖先父子状态等 - implementCompensateTorrUpdateAncestorNodeStatusEtc
     ImplementCompensateTorrUpdateAncestorNodeStatusEtcRespDto implementCompensateTorrUpdateAncestorNodeStatusEtcRespDto = null;
    ImplementCompensateTorrUpdateAncestorNodeStatusEtcReqDto implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto=new ImplementCompensateTorrUpdateAncestorNodeStatusEtcReqDto();
  if(reqDto!=null){
      implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto.setCheckItemCode(reqDto.getCheckItemCode());//SimpleFieldAssign//sourceId:783290_1
implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto.setParentEvaObjTargetCycleId(reqDto.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:783291_1
implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:783292_1
implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:783293_1
      implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:731108_1
implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:731109_1
implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:731110_1
    }

    /*D3执行补偿强托底更新祖先父子状态等[6026]   */
    Assert.isNull(implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto.getEvaObjTypeCode(),"B3执行强托底更新目标内容祖先父子状态等(管理)-D3执行补偿强托底更新祖先父子状态等-被评对象类型编码不能为空",false);
Assert.isNull(implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto.getEvaluationTemplateId(),"B3执行强托底更新目标内容祖先父子状态等(管理)-D3执行补偿强托底更新祖先父子状态等-冗余评价模板ID不能为空",false);
      implementCompensateTorrUpdateAncestorNodeStatusEtcRespDto = fwAppOffStateClient.implementCompensateTorrUpdateAncestorNodeStatusEtc(implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




BffImplementForceTorrUpdateTargetContAncestorNodeStatusEtcRespDto retData = new BffImplementForceTorrUpdateTargetContAncestorNodeStatusEtcRespDto();





return retData;
  }
/**
   * B3查询部门目标任务书父子状态列表(管理)[6105]
   * gen by moon at 6/5/2023, 6:41:36 AM
   */
    @Trace(operationName = "B3查询部门目标任务书父子状态列表(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffQueryDeptTargetBookTreeParentStateListRespDto queryDeptTargetBookTreeParentStateList(BffQueryDeptTargetBookTreeParentStateListReqDto reqDto){


       BatchQueryDeptTargetBookTreeParentStateListByIdsRespDto batchQueryDeptTargetBookTreeParentStateListByIdsRespDto_1 =null;
//步骤0: D3查询部门目标任务书父子状态列表ByIds - batchQueryDeptTargetBookTreeParentStateListByIds
     BatchQueryDeptTargetBookTreeParentStateListByIdsRespDto batchQueryDeptTargetBookTreeParentStateListByIdsRespDto = null;
    BatchQueryDeptTargetBookTreeParentStateListByIdsReqDto batchQueryDeptTargetBookTreeParentStateListByIdsReqDto=new BatchQueryDeptTargetBookTreeParentStateListByIdsReqDto();
  batchQueryDeptTargetBookTreeParentStateListByIdsReqDto.setEmploySceneTypeCode("USED_DEPT_TARGET_TASK_WEIGHT_SET");//sourceId:1011384_1
if(reqDto!=null){
      batchQueryDeptTargetBookTreeParentStateListByIdsReqDto.setAssistNodeStatusList(reqDto.getAssistNodeStatusList());//list-field-assign//sourceId:763727_1
      batchQueryDeptTargetBookTreeParentStateListByIdsReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:763712_1
    }

    /*D3查询部门目标任务书父子状态列表ByIds[6106]   */
    Assert.isNull(batchQueryDeptTargetBookTreeParentStateListByIdsReqDto.getEmploySceneTypeCode(),"B3查询部门目标任务书父子状态列表(管理)-D3查询部门目标任务书父子状态列表ByIds-使用场景编码不能为空",false);
    Assert.isNull(batchQueryDeptTargetBookTreeParentStateListByIdsReqDto.getThemeContentId(),"B3查询部门目标任务书父子状态列表(管理)-D3查询部门目标任务书父子状态列表ByIds-主题内容ID不能为空",false);
      batchQueryDeptTargetBookTreeParentStateListByIdsRespDto = fwAppOffStateClient.batchQueryDeptTargetBookTreeParentStateListByIds(batchQueryDeptTargetBookTreeParentStateListByIdsReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      batchQueryDeptTargetBookTreeParentStateListByIdsRespDto_1 = batchQueryDeptTargetBookTreeParentStateListByIdsRespDto;

BffQueryDeptTargetBookTreeParentStateListRespDto retData = new BffQueryDeptTargetBookTreeParentStateListRespDto();
  if(batchQueryDeptTargetBookTreeParentStateListByIdsRespDto_1!=null){
      retData.setAssistNodeStatusList(batchQueryDeptTargetBookTreeParentStateListByIdsRespDto_1.getAssistNodeStatusList().stream().map(item -> BeanUtil.toBean(item, BffAssistNodeStatusDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:763728_1
    }




return retData;
  }
/**
   * B3-11高层返回第一步(管理)[2987]
   * gen by moon at 2/7/2024, 4:39:10 AM
   */
    @Trace(operationName = "B3-11高层返回第一步(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffUpdateTopReturnFirstStepRespDto updateTopReturnFirstStep(BffUpdateTopReturnFirstStepReqDto reqDto){


ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto_1 =null;
//virtualUsage D2-执行并发行为主题锁(公共)  61094
      ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto = null;
    ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto=new ImplementConcBhvThemeLockComComReqDto();
  implementConcBhvThemeLockComComReqDto.setPreventConcurrentLockingUnlocking("LOCK");//sourceId:1540005_1_61094
implementConcBhvThemeLockComComReqDto.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540006_1_61094
implementConcBhvThemeLockComComReqDto.setDuration(Long.valueOf(15));//CUSTOM_CONVENTION//sourceId:1540011_1_61094
implementConcBhvThemeLockComComReqDto.setTimeUnitType("MINUTES");//sourceId:1540012_1_61094
implementConcBhvThemeLockComComReqDto.setHandlingMethodConcurrentLockFailure("CONCURRENT_LOCK_FAILURE_NO_ERROR_REPORTED");//sourceId:1540013_1_61094
if(reqDto!=null){
      implementConcBhvThemeLockComComReqDto.setCommPrimaryKey(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540007_1_61094
    }

    /*D2-执行并发行为主题锁(公共)[8388]   */
    Assert.isNull(implementConcBhvThemeLockComComReqDto.getPreventConcurrentLockingUnlocking(),"B3-11高层返回第一步(管理)-D2-执行并发行为主题锁(公共)-防并发上锁or解锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getBehaviorThemeLockCode(),"B3-11高层返回第一步(管理)-D2-执行并发行为主题锁(公共)-行为主题锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getCommPrimaryKey(),"B3-11高层返回第一步(管理)-D2-执行并发行为主题锁(公共)-通用主键ID不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getDuration(),"B3-11高层返回第一步(管理)-D2-执行并发行为主题锁(公共)-锁定时长不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getTimeUnitType(),"B3-11高层返回第一步(管理)-D2-执行并发行为主题锁(公共)-时间单位类型不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getHandlingMethodConcurrentLockFailure(),"B3-11高层返回第一步(管理)-D2-执行并发行为主题锁(公共)-并发上锁失败处理方式不能为空",false);
      implementConcBhvThemeLockComComRespDto = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((implementConcBhvThemeLockComComRespDto!= null&&  implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() !=null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("EMPTY_LOCK_SUCCESSFUL"))) {
        //if(D2执行并发高中基层步骤变更上锁(公共).防并发上锁情况 等于 空上锁成功)  47482

ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto = null;
    ImplementTopMidBasicGuideStepRoomReqDto implementTopMidBasicGuideStepRoomReqDto=new ImplementTopMidBasicGuideStepRoomReqDto();
  implementTopMidBasicGuideStepRoomReqDto.setRollbackPlanEditDiv("1");//CUSTOM_CONVENTION//sourceId:1203544_1_51036
implementTopMidBasicGuideStepRoomReqDto.setBatchOperateScene("TOP");//sourceId:1203545_1_51036
if(reqDto!=null){
      implementTopMidBasicGuideStepRoomReqDto.setWeightSetWay(reqDto.getWeightSetWay());//SimpleFieldAssign//sourceId:1203546_1_51036
    }

    /*D3执行高层导向步骤房间[7600]   */
    Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getRollbackPlanEditDiv(),"B3-11高层返回第一步(管理)-D3执行高层导向步骤房间-返回编制规划不能为空",false);
Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getBatchOperateScene(),"B3-11高层返回第一步(管理)-D3执行高层导向步骤房间-高/中/基层操作场景不能为空",false);
Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getWeightSetWay(),"B3-11高层返回第一步(管理)-D3执行高层导向步骤房间-权重设置方式不能为空",false);
      implementTopMidBasicGuideStepRoomRespDto = fwAppEvaSystemClient.implementTopMidBasicGuideStepRoom(implementTopMidBasicGuideStepRoomReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      implementTopMidBasicGuideStepRoomRespDto_1 = implementTopMidBasicGuideStepRoomRespDto;
ImplementTopMidBasicCurrentBstepJudgeComRespDto implementTopMidBasicCurrentBstepJudgeComRespDto = null;
    if(implementTopMidBasicGuideStepRoomRespDto !=null){
    ImplementTopMidBasicCurrentBstepJudgeComReqDto implementTopMidBasicCurrentBstepJudgeComReqDto=new ImplementTopMidBasicCurrentBstepJudgeComReqDto();
implementTopMidBasicCurrentBstepJudgeComReqDto.setBatchOperateScene("TOP");//sourceId:1089806_1_47713
if(reqDto!=null){
      implementTopMidBasicCurrentBstepJudgeComReqDto.setEntityId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1089802_1_47713
implementTopMidBasicCurrentBstepJudgeComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1089803_1_47713
    }
if(implementTopMidBasicGuideStepRoomRespDto!=null){
      implementTopMidBasicCurrentBstepJudgeComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:1089805_1_47713
    }

    /*D3执行高层当前步骤判断(公共)[7303]   */
    Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getEntityId(),"B3-11高层返回第一步(管理)-D3执行高层当前步骤判断(公共)-步骤内容实例ID不能为空",false);
Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getStepRoomValue(),"B3-11高层返回第一步(管理)-D3执行高层当前步骤判断(公共)-进入步骤房间值不能为空",false);
Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getThemeContentId(),"B3-11高层返回第一步(管理)-D3执行高层当前步骤判断(公共)-主题内容ID不能为空",false);
Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getBatchOperateScene(),"B3-11高层返回第一步(管理)-D3执行高层当前步骤判断(公共)-高/中/基层操作场景不能为空",false);
      implementTopMidBasicCurrentBstepJudgeComRespDto = fwAppOffStateClient.implementTopMidBasicCurrentBstepJudgeCom(implementTopMidBasicCurrentBstepJudgeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((implementTopMidBasicCurrentBstepJudgeComRespDto!= null&&  implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() !=null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("FALSE"))) {
        //if(D3执行高中基层当前步骤判断(公共).是否相等 等于 否)  47714

     UpdateTopReturnFirstStepComRespDto updateTopReturnFirstStepComRespDto = null;
    if(implementTopMidBasicGuideStepRoomRespDto !=null){
    UpdateTopReturnFirstStepComReqDto updateTopReturnFirstStepComReqDto=new UpdateTopReturnFirstStepComReqDto();
  if(reqDto!=null){
      updateTopReturnFirstStepComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:870610_1_47716
updateTopReturnFirstStepComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:665946_1_47716
updateTopReturnFirstStepComReqDto.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:847693_1_47716
updateTopReturnFirstStepComReqDto.setBatchCurrentStatus(reqDto.getBatchCurrentStatus());//SimpleFieldAssign//sourceId:856594_1_47716
    }
if(implementTopMidBasicGuideStepRoomRespDto!=null){
      updateTopReturnFirstStepComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:847692_1_47716
    }

    /*D3-11高层返回第一步(公共)[3752]   */
    Assert.isNull(updateTopReturnFirstStepComReqDto.getTargetId(),"B3-11高层返回第一步(管理)-D3-11高层返回第一步(公共)-冗余目标ID不能为空",false);
Assert.isNull(updateTopReturnFirstStepComReqDto.getEvaluationTemplateId(),"B3-11高层返回第一步(管理)-D3-11高层返回第一步(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(updateTopReturnFirstStepComReqDto.getStepRoomValue(),"B3-11高层返回第一步(管理)-D3-11高层返回第一步(公共)-进入步骤房间值不能为空",false);
Assert.isNull(updateTopReturnFirstStepComReqDto.getBatchCode(),"B3-11高层返回第一步(管理)-D3-11高层返回第一步(公共)-批次标识不能为空",false);
Assert.isNull(updateTopReturnFirstStepComReqDto.getBatchCurrentStatus(),"B3-11高层返回第一步(管理)-D3-11高层返回第一步(公共)-批次现状不能为空",false);
      updateTopReturnFirstStepComRespDto = fwAppOffStateClient.updateTopReturnFirstStepCom(updateTopReturnFirstStepComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto_2 = null;
    ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto_1=new ImplementConcBhvThemeLockComComReqDto();
  implementConcBhvThemeLockComComReqDto_1.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1540016_1_61097
implementConcBhvThemeLockComComReqDto_1.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540017_1_61097
implementConcBhvThemeLockComComReqDto_1.setWhetherUnlockBulk("FALSE");//sourceId:1540025_1_61097
if(reqDto!=null){
      implementConcBhvThemeLockComComReqDto_1.setCommPrimaryKey(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540018_1_61097
    }

    /*D2-执行并发行为主题锁(公共)[8388]   */
    Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getPreventConcurrentLockingUnlocking(),"B3-11高层返回第一步(管理)-D2-执行并发行为主题锁(公共)-防并发上锁or解锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getBehaviorThemeLockCode(),"B3-11高层返回第一步(管理)-D2-执行并发行为主题锁(公共)-行为主题锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getCommPrimaryKey(),"B3-11高层返回第一步(管理)-D2-执行并发行为主题锁(公共)-通用主键ID不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getWhetherUnlockBulk(),"B3-11高层返回第一步(管理)-D2-执行并发行为主题锁(公共)-是否批量解锁不能为空",false);
      implementConcBhvThemeLockComComRespDto_2 = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



      }
else if((implementTopMidBasicCurrentBstepJudgeComRespDto!= null&&  implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() !=null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("TRUE"))){
       //elseif(D3执行高层当前步骤判断(公共).是否相等 等于 是)  61098

//异常结束 61150
      throw new BizException("B10100289","对不起！当前房间已变化，请刷新页面~",false);
    }
      }
else if((implementConcBhvThemeLockComComRespDto!= null&&  implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() !=null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("CONCURRENT_LOCK_FAILURE"))){
       //elseif(D2执行并发高中基层步骤变更上锁(公共).防并发上锁情况 等于 并发上锁失败)  61095

//异常结束 61096
      throw new BizException("B10100288","操作过于频繁，请稍后再试~",false);
      }
BffUpdateTopReturnFirstStepRespDto retData = new BffUpdateTopReturnFirstStepRespDto();
  if(implementTopMidBasicGuideStepRoomRespDto_1!=null){
      retData.setStepNameCode(implementTopMidBasicGuideStepRoomRespDto_1.getStepNameCode());//SimpleFieldAssign//sourceId:1203547_1
    }




return retData;
  }
/**
   * B3-11高层返回第二步(管理)[2990]
   * gen by moon at 2/24/2024, 9:12:08 PM
   */
    @Trace(operationName = "B3-11高层返回第二步(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffUpdateTopReturnSecondStepRespDto updateTopReturnSecondStep(BffUpdateTopReturnSecondStepReqDto reqDto){


       ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto_1 =null;
//virtualUsage D2执行上并发高中基层步骤变更锁(公共)  61139
      ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto = null;
    ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto=new ImplementConcBhvThemeLockComComReqDto();
  implementConcBhvThemeLockComComReqDto.setPreventConcurrentLockingUnlocking("LOCK");//sourceId:1540170_1_61139
implementConcBhvThemeLockComComReqDto.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540171_1_61139
implementConcBhvThemeLockComComReqDto.setDuration(Long.valueOf(5));//CUSTOM_CONVENTION//sourceId:1540173_1_61139
implementConcBhvThemeLockComComReqDto.setTimeUnitType("MINUTES");//sourceId:1540174_1_61139
implementConcBhvThemeLockComComReqDto.setHandlingMethodConcurrentLockFailure("CONCURRENT_LOCK_FAILURE_NO_ERROR_REPORTED");//sourceId:1540175_1_61139
if(reqDto!=null){
      implementConcBhvThemeLockComComReqDto.setCommPrimaryKey(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540172_1_61139
    }

    /*D2执行上并发高中基层步骤变更锁(公共)[8388]   */
    Assert.isNull(implementConcBhvThemeLockComComReqDto.getPreventConcurrentLockingUnlocking(),"B3-11高层返回第二步(管理)-D2执行上并发高中基层步骤变更锁(公共)-防并发上锁or解锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getBehaviorThemeLockCode(),"B3-11高层返回第二步(管理)-D2执行上并发高中基层步骤变更锁(公共)-行为主题锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getCommPrimaryKey(),"B3-11高层返回第二步(管理)-D2执行上并发高中基层步骤变更锁(公共)-通用主键ID不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getDuration(),"B3-11高层返回第二步(管理)-D2执行上并发高中基层步骤变更锁(公共)-锁定时长不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getTimeUnitType(),"B3-11高层返回第二步(管理)-D2执行上并发高中基层步骤变更锁(公共)-时间单位类型不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getHandlingMethodConcurrentLockFailure(),"B3-11高层返回第二步(管理)-D2执行上并发高中基层步骤变更锁(公共)-并发上锁失败处理方式不能为空",false);
      implementConcBhvThemeLockComComRespDto = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((implementConcBhvThemeLockComComRespDto!= null&&  implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() !=null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("EMPTY_LOCK_SUCCESSFUL"))) {
        //if(D2执行上并发高中基层步骤变更锁(公共).防并发上锁情况 等于 空上锁成功)  61140

      ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto = null;
    ImplementTopMidBasicGuideStepRoomReqDto implementTopMidBasicGuideStepRoomReqDto=new ImplementTopMidBasicGuideStepRoomReqDto();
  implementTopMidBasicGuideStepRoomReqDto.setRollbackTargetDiv("1");//CUSTOM_CONVENTION//sourceId:1203567_1_61143
implementTopMidBasicGuideStepRoomReqDto.setBatchOperateScene("TOP");//sourceId:1203568_1_61143
if(reqDto!=null){
      implementTopMidBasicGuideStepRoomReqDto.setWeightSetWay(reqDto.getWeightSetWay());//SimpleFieldAssign//sourceId:1203569_1_61143
    }

    /*D3执行高层导向步骤房间[7600]   */
    Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getRollbackTargetDiv(),"B3-11高层返回第二步(管理)-D3执行高层导向步骤房间-返回目标任务分工不能为空",false);
Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getBatchOperateScene(),"B3-11高层返回第二步(管理)-D3执行高层导向步骤房间-高/中/基层操作场景不能为空",false);
Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getWeightSetWay(),"B3-11高层返回第二步(管理)-D3执行高层导向步骤房间-权重设置方式不能为空",false);
      implementTopMidBasicGuideStepRoomRespDto = fwAppEvaSystemClient.implementTopMidBasicGuideStepRoom(implementTopMidBasicGuideStepRoomReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      implementTopMidBasicGuideStepRoomRespDto_1 = implementTopMidBasicGuideStepRoomRespDto;
      ImplementTopMidBasicCurrentBstepJudgeComRespDto implementTopMidBasicCurrentBstepJudgeComRespDto = null;
    if(implementTopMidBasicGuideStepRoomRespDto !=null){
          ImplementTopMidBasicCurrentBstepJudgeComReqDto implementTopMidBasicCurrentBstepJudgeComReqDto=new ImplementTopMidBasicCurrentBstepJudgeComReqDto();
  implementTopMidBasicCurrentBstepJudgeComReqDto.setBatchOperateScene("TOP");//sourceId:1203827_1_61144
if(reqDto!=null){
      implementTopMidBasicCurrentBstepJudgeComReqDto.setEntityId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1203823_1_61144
implementTopMidBasicCurrentBstepJudgeComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1203824_1_61144
    }
if(implementTopMidBasicGuideStepRoomRespDto!=null){
      implementTopMidBasicCurrentBstepJudgeComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:1203826_1_61144
    }

    /*D3执行高层当前步骤判断(公共)[7303]   */
    Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getEntityId(),"B3-11高层返回第二步(管理)-D3执行高层当前步骤判断(公共)-步骤内容实例ID不能为空",false);
Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getStepRoomValue(),"B3-11高层返回第二步(管理)-D3执行高层当前步骤判断(公共)-进入步骤房间值不能为空",false);
Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getThemeContentId(),"B3-11高层返回第二步(管理)-D3执行高层当前步骤判断(公共)-主题内容ID不能为空",false);
Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getBatchOperateScene(),"B3-11高层返回第二步(管理)-D3执行高层当前步骤判断(公共)-高/中/基层操作场景不能为空",false);
      implementTopMidBasicCurrentBstepJudgeComRespDto = fwAppOffStateClient.implementTopMidBasicCurrentBstepJudgeCom(implementTopMidBasicCurrentBstepJudgeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((implementTopMidBasicCurrentBstepJudgeComRespDto!= null&&  implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() !=null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("FALSE"))) {
        //if(D3执行高层当前步骤判断(公共).是否相等 等于 否)  61145

     UpdateTopReturnSecondStepRespDto updateTopReturnSecondStepRespDto = null;
    if(implementTopMidBasicGuideStepRoomRespDto !=null){
    UpdateTopReturnSecondStepReqDto updateTopReturnSecondStepReqDto=new UpdateTopReturnSecondStepReqDto();
  if(reqDto!=null){
      updateTopReturnSecondStepReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:850255_1_61146
updateTopReturnSecondStepReqDto.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:857501_1_61146
updateTopReturnSecondStepReqDto.setBatchCurrentStatus(reqDto.getBatchCurrentStatus());//SimpleFieldAssign//sourceId:857502_1_61146
    }
  if(implementTopMidBasicGuideStepRoomRespDto !=null)
  {
      updateTopReturnSecondStepReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:1203583_1_61146
  }


    /*D3-11修改高层返回第二步[3001]   */
    Assert.isNull(updateTopReturnSecondStepReqDto.getEvaluationTemplateId(),"B3-11高层返回第二步(管理)-D3-11修改高层返回第二步-冗余评价模板ID不能为空",false);
Assert.isNull(updateTopReturnSecondStepReqDto.getStepRoomValue(),"B3-11高层返回第二步(管理)-D3-11修改高层返回第二步-进入步骤房间值不能为空",false);
Assert.isNull(updateTopReturnSecondStepReqDto.getBatchCode(),"B3-11高层返回第二步(管理)-D3-11修改高层返回第二步-批次标识不能为空",false);
Assert.isNull(updateTopReturnSecondStepReqDto.getBatchCurrentStatus(),"B3-11高层返回第二步(管理)-D3-11修改高层返回第二步-批次现状不能为空",false);
      updateTopReturnSecondStepRespDto = fwAppOffStateClient.updateTopReturnSecondStep(updateTopReturnSecondStepReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto_2 = null;
    ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto_1=new ImplementConcBhvThemeLockComComReqDto();
  implementConcBhvThemeLockComComReqDto_1.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1540176_1_61147
implementConcBhvThemeLockComComReqDto_1.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540177_1_61147
implementConcBhvThemeLockComComReqDto_1.setWhetherUnlockBulk("FALSE");//sourceId:1540179_1_61147
if(reqDto!=null){
      implementConcBhvThemeLockComComReqDto_1.setCommPrimaryKey(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540178_1_61147
    }

    /*D2执行并发行为主题解锁(公共)[8388]   */
    Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getPreventConcurrentLockingUnlocking(),"B3-11高层返回第二步(管理)-D2执行并发行为主题解锁(公共)-防并发上锁or解锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getBehaviorThemeLockCode(),"B3-11高层返回第二步(管理)-D2执行并发行为主题解锁(公共)-行为主题锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getCommPrimaryKey(),"B3-11高层返回第二步(管理)-D2执行并发行为主题解锁(公共)-通用主键ID不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getWhetherUnlockBulk(),"B3-11高层返回第二步(管理)-D2执行并发行为主题解锁(公共)-是否批量解锁不能为空",false);
      implementConcBhvThemeLockComComRespDto_2 = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



           }
else if((implementTopMidBasicCurrentBstepJudgeComRespDto!= null&&  implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() !=null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("TRUE"))){
       //elseif(D3执行高层当前步骤判断(公共).是否相等 等于 是)  61148

//异常结束 61149
      throw new BizException("B10100289","对不起！当前房间已变化，请刷新页面~",false);
    }
      }
else if((implementConcBhvThemeLockComComRespDto!= null&&  implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() !=null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("CONCURRENT_LOCK_FAILURE"))){
       //elseif(D2执行上并发高中基层步骤变更锁(公共).防并发上锁情况 等于 并发上锁失败)  61141

//异常结束 61142
      throw new BizException("B10100288","操作过于频繁，请稍后再试~",false);
      }
BffUpdateTopReturnSecondStepRespDto retData = new BffUpdateTopReturnSecondStepRespDto();
  if(implementTopMidBasicGuideStepRoomRespDto_1!=null){
      retData.setStepNameCode(implementTopMidBasicGuideStepRoomRespDto_1.getStepNameCode());//SimpleFieldAssign//sourceId:1203584_1
    }




return retData;
  }
/**
   * B3-3中层返回第一步(管理)[3038]
   * gen by moon at 2/24/2024, 1:08:43 PM
   */
    @Trace(operationName = "B3-3中层返回第一步(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffUpdateMidReturnFirstStepRespDto updateMidReturnFirstStep(BffUpdateMidReturnFirstStepReqDto reqDto){


       ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto_1 =null;
//virtualUsage D2执行上并发中层步骤变更锁(公共)  61201
      ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto = null;
    ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto=new ImplementConcBhvThemeLockComComReqDto();
  implementConcBhvThemeLockComComReqDto.setPreventConcurrentLockingUnlocking("LOCK");//sourceId:1540363_1_61201
implementConcBhvThemeLockComComReqDto.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540364_1_61201
implementConcBhvThemeLockComComReqDto.setDuration(Long.valueOf(15));//CUSTOM_CONVENTION//sourceId:1540366_1_61201
implementConcBhvThemeLockComComReqDto.setTimeUnitType("MINUTES");//sourceId:1540367_1_61201
implementConcBhvThemeLockComComReqDto.setHandlingMethodConcurrentLockFailure("CONCURRENT_LOCK_FAILURE_NO_ERROR_REPORTED");//sourceId:1540368_1_61201
if(reqDto!=null){
      implementConcBhvThemeLockComComReqDto.setCommPrimaryKey(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:1540365_1_61201
    }

    /*D2执行上并发中层步骤变更锁(公共)[8388]   */
    Assert.isNull(implementConcBhvThemeLockComComReqDto.getPreventConcurrentLockingUnlocking(),"B3-3中层返回第一步(管理)-D2执行上并发中层步骤变更锁(公共)-防并发上锁or解锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getBehaviorThemeLockCode(),"B3-3中层返回第一步(管理)-D2执行上并发中层步骤变更锁(公共)-行为主题锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getCommPrimaryKey(),"B3-3中层返回第一步(管理)-D2执行上并发中层步骤变更锁(公共)-通用主键ID不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getDuration(),"B3-3中层返回第一步(管理)-D2执行上并发中层步骤变更锁(公共)-锁定时长不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getTimeUnitType(),"B3-3中层返回第一步(管理)-D2执行上并发中层步骤变更锁(公共)-时间单位类型不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getHandlingMethodConcurrentLockFailure(),"B3-3中层返回第一步(管理)-D2执行上并发中层步骤变更锁(公共)-并发上锁失败处理方式不能为空",false);
      implementConcBhvThemeLockComComRespDto = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((implementConcBhvThemeLockComComRespDto!= null&&  implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() !=null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("EMPTY_LOCK_SUCCESSFUL"))) {
        //if(D2执行上并发中层步骤变更锁(公共).防并发上锁情况 等于 空上锁成功)  47507

ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto = null;
    ImplementTopMidBasicGuideStepRoomReqDto implementTopMidBasicGuideStepRoomReqDto=new ImplementTopMidBasicGuideStepRoomReqDto();
  implementTopMidBasicGuideStepRoomReqDto.setRollbackLeaderTargetDiv("1");//CUSTOM_CONVENTION//sourceId:1203797_1_51061
implementTopMidBasicGuideStepRoomReqDto.setBatchOperateScene("MID");//sourceId:1203798_1_51061
if(reqDto!=null){
      implementTopMidBasicGuideStepRoomReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1203799_1_51061
implementTopMidBasicGuideStepRoomReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1203800_1_51061
    }

    /*D3执行中层导向步骤房间[7600]   */
    Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getRollbackLeaderTargetDiv(),"B3-3中层返回第一步(管理)-D3执行中层导向步骤房间-返回牵头目标安排不能为空",false);
Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getBatchOperateScene(),"B3-3中层返回第一步(管理)-D3执行中层导向步骤房间-高/中/基层操作场景不能为空",false);
Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getDeptId(),"B3-3中层返回第一步(管理)-D3执行中层导向步骤房间-一级部门ID不能为空",false);
Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getEvaluationTemplateId(),"B3-3中层返回第一步(管理)-D3执行中层导向步骤房间-冗余评价模板ID不能为空",false);
      implementTopMidBasicGuideStepRoomRespDto = fwAppEvaSystemClient.implementTopMidBasicGuideStepRoom(implementTopMidBasicGuideStepRoomReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      implementTopMidBasicGuideStepRoomRespDto_1 = implementTopMidBasicGuideStepRoomRespDto;
ImplementTopMidBasicCurrentBstepJudgeComRespDto implementTopMidBasicCurrentBstepJudgeComRespDto = null;
    if(implementTopMidBasicGuideStepRoomRespDto !=null){
    ImplementTopMidBasicCurrentBstepJudgeComReqDto implementTopMidBasicCurrentBstepJudgeComReqDto=new ImplementTopMidBasicCurrentBstepJudgeComReqDto();
implementTopMidBasicCurrentBstepJudgeComReqDto.setBatchOperateScene("MID");//sourceId:1091553_1_47738
if(reqDto!=null){
      implementTopMidBasicCurrentBstepJudgeComReqDto.setEntityId(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:1091549_1_47738
implementTopMidBasicCurrentBstepJudgeComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1091550_1_47738
    }
if(implementTopMidBasicGuideStepRoomRespDto!=null){
      implementTopMidBasicCurrentBstepJudgeComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:1091552_1_47738
    }

    /*D3执行中层当前步骤判断(公共)[7303]   */
    Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getEntityId(),"B3-3中层返回第一步(管理)-D3执行中层当前步骤判断(公共)-步骤内容实例ID不能为空",false);
Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getStepRoomValue(),"B3-3中层返回第一步(管理)-D3执行中层当前步骤判断(公共)-进入步骤房间值不能为空",false);
Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getThemeContentId(),"B3-3中层返回第一步(管理)-D3执行中层当前步骤判断(公共)-主题内容ID不能为空",false);
Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getBatchOperateScene(),"B3-3中层返回第一步(管理)-D3执行中层当前步骤判断(公共)-高/中/基层操作场景不能为空",false);
      implementTopMidBasicCurrentBstepJudgeComRespDto = fwAppOffStateClient.implementTopMidBasicCurrentBstepJudgeCom(implementTopMidBasicCurrentBstepJudgeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((implementTopMidBasicCurrentBstepJudgeComRespDto!= null&&  implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() !=null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("FALSE"))) {
        //if(D3执行中层当前步骤判断(公共).是否相等 等于 否)  47739

     ImplementMidReturnFirstStepComRespDto implementMidReturnFirstStepComRespDto = null;
    if(implementTopMidBasicGuideStepRoomRespDto !=null){
    ImplementMidReturnFirstStepComReqDto implementMidReturnFirstStepComReqDto=new ImplementMidReturnFirstStepComReqDto();
implementMidReturnFirstStepComReqDto.setUseTypeCode("USE_MID_ISSUE_OBJTIVE");//CUSTOM_CONVENTION//sourceId:1091556_1_47740
  if(reqDto!=null){
      implementMidReturnFirstStepComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:849253_1_47740
implementMidReturnFirstStepComReqDto.setDeptTargetTaskBookId(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:849254_1_47740
implementMidReturnFirstStepComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:849255_1_47740
implementMidReturnFirstStepComReqDto.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:849257_1_47740
implementMidReturnFirstStepComReqDto.setBatchCurrentStatus(reqDto.getBatchCurrentStatus());//SimpleFieldAssign//sourceId:856642_1_47740
implementMidReturnFirstStepComReqDto.setOrgInductionRecordList(reqDto.getOrgInductionRecordList());//list-field-assign//sourceId:1550907_1_47740
implementMidReturnFirstStepComReqDto.setBackMsgSendType(reqDto.getBackMsgSendType());//SimpleFieldAssign//sourceId:1550908_1_47740
implementMidReturnFirstStepComReqDto.setMessageContent(reqDto.getMessageContent());//SimpleFieldAssign//sourceId:1550909_1_47740
    }
if(implementTopMidBasicGuideStepRoomRespDto!=null){
      implementMidReturnFirstStepComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:849256_1_47740
    }

    /*D3执行中层返回第一步(公共)[3748]   */
    Assert.isNull(implementMidReturnFirstStepComReqDto.getDeptId(),"B3-3中层返回第一步(管理)-D3执行中层返回第一步(公共)-部门ID不能为空",false);
Assert.isNull(implementMidReturnFirstStepComReqDto.getDeptTargetTaskBookId(),"B3-3中层返回第一步(管理)-D3执行中层返回第一步(公共)-部门目标任务书ID不能为空",false);
Assert.isNull(implementMidReturnFirstStepComReqDto.getEvaluationTemplateId(),"B3-3中层返回第一步(管理)-D3执行中层返回第一步(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementMidReturnFirstStepComReqDto.getStepRoomValue(),"B3-3中层返回第一步(管理)-D3执行中层返回第一步(公共)-进入步骤房间值不能为空",false);
Assert.isNull(implementMidReturnFirstStepComReqDto.getBatchCode(),"B3-3中层返回第一步(管理)-D3执行中层返回第一步(公共)-批次标识不能为空",false);
Assert.isNull(implementMidReturnFirstStepComReqDto.getBatchCurrentStatus(),"B3-3中层返回第一步(管理)-D3执行中层返回第一步(公共)-批次现状不能为空",false);
Assert.isNull(implementMidReturnFirstStepComReqDto.getUseTypeCode(),"B3-3中层返回第一步(管理)-D3执行中层返回第一步(公共)-用途类型编码不能为空",false);
Assert.isNull(implementMidReturnFirstStepComReqDto.getBackMsgSendType(),"B3-3中层返回第一步(管理)-D3执行中层返回第一步(公共)-回退消息发送类型不能为空",false);
      implementMidReturnFirstStepComRespDto = fwAppOffStateClient.implementMidReturnFirstStepCom(implementMidReturnFirstStepComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto_2 = null;
    ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto_1=new ImplementConcBhvThemeLockComComReqDto();
  implementConcBhvThemeLockComComReqDto_1.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1540369_1_61202
implementConcBhvThemeLockComComReqDto_1.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540370_1_61202
implementConcBhvThemeLockComComReqDto_1.setWhetherUnlockBulk("FALSE");//sourceId:1540372_1_61202
if(reqDto!=null){
      implementConcBhvThemeLockComComReqDto_1.setCommPrimaryKey(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:1540371_1_61202
    }

    /*D2执行并发行为主题解锁(公共)[8388]   */
    Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getPreventConcurrentLockingUnlocking(),"B3-3中层返回第一步(管理)-D2执行并发行为主题解锁(公共)-防并发上锁or解锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getBehaviorThemeLockCode(),"B3-3中层返回第一步(管理)-D2执行并发行为主题解锁(公共)-行为主题锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getCommPrimaryKey(),"B3-3中层返回第一步(管理)-D2执行并发行为主题解锁(公共)-通用主键ID不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getWhetherUnlockBulk(),"B3-3中层返回第一步(管理)-D2执行并发行为主题解锁(公共)-是否批量解锁不能为空",false);
      implementConcBhvThemeLockComComRespDto_2 = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



      }
else if((implementTopMidBasicCurrentBstepJudgeComRespDto!= null&&  implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() !=null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("TRUE"))){
       //elseif(D3执行中层当前步骤判断(公共).是否相等 等于 是)  61203

//异常结束 61204
      throw new BizException("B10100289","对不起！当前房间已变化，请刷新页面~",false);
    }
      }
else if((implementConcBhvThemeLockComComRespDto!= null&&  implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() !=null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("CONCURRENT_LOCK_FAILURE"))){
       //elseif(D2执行上并发中层步骤变更锁(公共).防并发上锁情况 等于 并发上锁失败)  61205

//异常结束 61206
      throw new BizException("B10100288","操作过于频繁，请稍后再试~",false);
      }
BffUpdateMidReturnFirstStepRespDto retData = new BffUpdateMidReturnFirstStepRespDto();
  if(implementTopMidBasicGuideStepRoomRespDto_1!=null){
      retData.setStepNameCode(implementTopMidBasicGuideStepRoomRespDto_1.getStepNameCode());//SimpleFieldAssign//sourceId:1203801_1
    }




return retData;
  }
/**
   * B3中层返回第二步(管理)[3046]
   * gen by moon at 2/24/2024, 1:08:50 PM
   */
    @Trace(operationName = "B3中层返回第二步(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffUpdateMidReturnSecondStepRespDto updateMidReturnSecondStep(BffUpdateMidReturnSecondStepReqDto reqDto){


       ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto_1 =null;
//virtualUsage D2执行上并发中层步骤变更锁(公共)  61191
      ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto = null;
    ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto=new ImplementConcBhvThemeLockComComReqDto();
  implementConcBhvThemeLockComComReqDto.setPreventConcurrentLockingUnlocking("LOCK");//sourceId:1540330_1_61191
implementConcBhvThemeLockComComReqDto.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540331_1_61191
implementConcBhvThemeLockComComReqDto.setDuration(Long.valueOf(15));//CUSTOM_CONVENTION//sourceId:1540333_1_61191
implementConcBhvThemeLockComComReqDto.setTimeUnitType("MINUTES");//sourceId:1540334_1_61191
implementConcBhvThemeLockComComReqDto.setHandlingMethodConcurrentLockFailure("CONCURRENT_LOCK_FAILURE_NO_ERROR_REPORTED");//sourceId:1540335_1_61191
if(reqDto!=null){
      implementConcBhvThemeLockComComReqDto.setCommPrimaryKey(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:1540332_1_61191
    }

    /*D2执行上并发中层步骤变更锁(公共)[8388]   */
    Assert.isNull(implementConcBhvThemeLockComComReqDto.getPreventConcurrentLockingUnlocking(),"B3中层返回第二步(管理)-D2执行上并发中层步骤变更锁(公共)-防并发上锁or解锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getBehaviorThemeLockCode(),"B3中层返回第二步(管理)-D2执行上并发中层步骤变更锁(公共)-行为主题锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getCommPrimaryKey(),"B3中层返回第二步(管理)-D2执行上并发中层步骤变更锁(公共)-通用主键ID不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getDuration(),"B3中层返回第二步(管理)-D2执行上并发中层步骤变更锁(公共)-锁定时长不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getTimeUnitType(),"B3中层返回第二步(管理)-D2执行上并发中层步骤变更锁(公共)-时间单位类型不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getHandlingMethodConcurrentLockFailure(),"B3中层返回第二步(管理)-D2执行上并发中层步骤变更锁(公共)-并发上锁失败处理方式不能为空",false);
      implementConcBhvThemeLockComComRespDto = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((implementConcBhvThemeLockComComRespDto!= null&&  implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() !=null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("EMPTY_LOCK_SUCCESSFUL"))) {
        //if(D2执行上并发中层步骤变更锁(公共).防并发上锁情况 等于 空上锁成功)  45921

      ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto = null;
    ImplementTopMidBasicGuideStepRoomReqDto implementTopMidBasicGuideStepRoomReqDto=new ImplementTopMidBasicGuideStepRoomReqDto();
  implementTopMidBasicGuideStepRoomReqDto.setRollbackExecuteTargetDiv("1");//CUSTOM_CONVENTION//sourceId:1203774_1_61192
implementTopMidBasicGuideStepRoomReqDto.setBatchOperateScene("MID");//sourceId:1203775_1_61192
if(reqDto!=null){
      implementTopMidBasicGuideStepRoomReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1203776_1_61192
implementTopMidBasicGuideStepRoomReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1203777_1_61192
    }

    /*D3执行中层导向步骤房间[7600]   */
    Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getRollbackExecuteTargetDiv(),"B3中层返回第二步(管理)-D3执行中层导向步骤房间-返回执行目标安排不能为空",false);
Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getBatchOperateScene(),"B3中层返回第二步(管理)-D3执行中层导向步骤房间-高/中/基层操作场景不能为空",false);
Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getDeptId(),"B3中层返回第二步(管理)-D3执行中层导向步骤房间-一级部门ID不能为空",false);
Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getEvaluationTemplateId(),"B3中层返回第二步(管理)-D3执行中层导向步骤房间-冗余评价模板ID不能为空",false);
      implementTopMidBasicGuideStepRoomRespDto = fwAppEvaSystemClient.implementTopMidBasicGuideStepRoom(implementTopMidBasicGuideStepRoomReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      implementTopMidBasicGuideStepRoomRespDto_1 = implementTopMidBasicGuideStepRoomRespDto;
ImplementTopMidBasicCurrentBstepJudgeComRespDto implementTopMidBasicCurrentBstepJudgeComRespDto = null;
    if(implementTopMidBasicGuideStepRoomRespDto !=null){
    ImplementTopMidBasicCurrentBstepJudgeComReqDto implementTopMidBasicCurrentBstepJudgeComReqDto=new ImplementTopMidBasicCurrentBstepJudgeComReqDto();
  implementTopMidBasicCurrentBstepJudgeComReqDto.setBatchOperateScene("MID");//sourceId:1091561_1_47752
if(reqDto!=null){
      implementTopMidBasicCurrentBstepJudgeComReqDto.setEntityId(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:1091557_1_47752
implementTopMidBasicCurrentBstepJudgeComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1091558_1_47752
    }
if(implementTopMidBasicGuideStepRoomRespDto!=null){
      implementTopMidBasicCurrentBstepJudgeComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:1091560_1_47752
    }

    /*D3执行中层当前步骤判断(公共)[7303]   */
    Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getEntityId(),"B3中层返回第二步(管理)-D3执行中层当前步骤判断(公共)-步骤内容实例ID不能为空",false);
Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getStepRoomValue(),"B3中层返回第二步(管理)-D3执行中层当前步骤判断(公共)-进入步骤房间值不能为空",false);
Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getThemeContentId(),"B3中层返回第二步(管理)-D3执行中层当前步骤判断(公共)-主题内容ID不能为空",false);
Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getBatchOperateScene(),"B3中层返回第二步(管理)-D3执行中层当前步骤判断(公共)-高/中/基层操作场景不能为空",false);
      implementTopMidBasicCurrentBstepJudgeComRespDto = fwAppOffStateClient.implementTopMidBasicCurrentBstepJudgeCom(implementTopMidBasicCurrentBstepJudgeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((implementTopMidBasicCurrentBstepJudgeComRespDto!= null&&  implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() !=null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("FALSE")&&implementTopMidBasicGuideStepRoomRespDto!= null&&  implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue() !=null && implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue().equals("EXECUTE_TARGET_ARRANGE_ROOM"))) {
        //if((D3执行中层当前步骤判断(公共).是否相等 等于 否 and D3执行中层导向步骤房间.进入步骤房间值 等于 执行目标安排房间))  47510

     ImplementMidReturnSecondStepComRespDto implementMidReturnSecondStepComRespDto = null;
    if(implementTopMidBasicGuideStepRoomRespDto !=null){
    ImplementMidReturnSecondStepComReqDto implementMidReturnSecondStepComReqDto=new ImplementMidReturnSecondStepComReqDto();
  implementMidReturnSecondStepComReqDto.setUseTypeCode("USE_MID_ISSUE_OBJTIVE");//CUSTOM_CONVENTION//sourceId:1091564_1_47511
  if(reqDto!=null){
      implementMidReturnSecondStepComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:849272_1_47511
implementMidReturnSecondStepComReqDto.setDeptTargetTaskBookId(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:849273_1_47511
implementMidReturnSecondStepComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:849274_1_47511
implementMidReturnSecondStepComReqDto.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:849276_1_47511
implementMidReturnSecondStepComReqDto.setBatchCurrentStatus(reqDto.getBatchCurrentStatus());//SimpleFieldAssign//sourceId:856626_1_47511
implementMidReturnSecondStepComReqDto.setOrgInductionRecordList(reqDto.getOrgInductionRecordList());//list-field-assign//sourceId:1550927_1_47511
implementMidReturnSecondStepComReqDto.setBackMsgSendType(reqDto.getBackMsgSendType());//SimpleFieldAssign//sourceId:1550928_1_47511
implementMidReturnSecondStepComReqDto.setMessageContent(reqDto.getMessageContent());//SimpleFieldAssign//sourceId:1550929_1_47511
    }
if(implementTopMidBasicGuideStepRoomRespDto!=null){
      implementMidReturnSecondStepComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:849275_1_47511
    }

    /*D3执行中层返回第二步(公共)[6330]   */
    Assert.isNull(implementMidReturnSecondStepComReqDto.getDeptId(),"B3中层返回第二步(管理)-D3执行中层返回第二步(公共)-部门ID不能为空",false);
Assert.isNull(implementMidReturnSecondStepComReqDto.getDeptTargetTaskBookId(),"B3中层返回第二步(管理)-D3执行中层返回第二步(公共)-部门目标任务书ID不能为空",false);
Assert.isNull(implementMidReturnSecondStepComReqDto.getEvaluationTemplateId(),"B3中层返回第二步(管理)-D3执行中层返回第二步(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementMidReturnSecondStepComReqDto.getStepRoomValue(),"B3中层返回第二步(管理)-D3执行中层返回第二步(公共)-进入步骤房间值不能为空",false);
Assert.isNull(implementMidReturnSecondStepComReqDto.getBatchCode(),"B3中层返回第二步(管理)-D3执行中层返回第二步(公共)-批次标识不能为空",false);
Assert.isNull(implementMidReturnSecondStepComReqDto.getBatchCurrentStatus(),"B3中层返回第二步(管理)-D3执行中层返回第二步(公共)-批次现状不能为空",false);
Assert.isNull(implementMidReturnSecondStepComReqDto.getUseTypeCode(),"B3中层返回第二步(管理)-D3执行中层返回第二步(公共)-用途类型编码不能为空",false);
      implementMidReturnSecondStepComRespDto = fwAppOffStateClient.implementMidReturnSecondStepCom(implementMidReturnSecondStepComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



      }
ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto_2 = null;
    ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto_1=new ImplementConcBhvThemeLockComComReqDto();
  implementConcBhvThemeLockComComReqDto_1.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1540336_1_61193
implementConcBhvThemeLockComComReqDto_1.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540337_1_61193
implementConcBhvThemeLockComComReqDto_1.setWhetherUnlockBulk("FALSE");//sourceId:1540339_1_61193
if(reqDto!=null){
      implementConcBhvThemeLockComComReqDto_1.setCommPrimaryKey(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:1540338_1_61193
    }

    /*D2执行并发行为主题解锁(公共)[8388]   */
    Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getPreventConcurrentLockingUnlocking(),"B3中层返回第二步(管理)-D2执行并发行为主题解锁(公共)-防并发上锁or解锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getBehaviorThemeLockCode(),"B3中层返回第二步(管理)-D2执行并发行为主题解锁(公共)-行为主题锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getCommPrimaryKey(),"B3中层返回第二步(管理)-D2执行并发行为主题解锁(公共)-通用主键ID不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getWhetherUnlockBulk(),"B3中层返回第二步(管理)-D2执行并发行为主题解锁(公共)-是否批量解锁不能为空",false);
      implementConcBhvThemeLockComComRespDto_2 = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



           }
else if((implementTopMidBasicCurrentBstepJudgeComRespDto!= null&&  implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() !=null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("FALSE")&&implementTopMidBasicGuideStepRoomRespDto!= null&&  implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue() !=null && implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue().equals("LEAD_TARGET_ARRANGE_ROOM"))){
       //elseif((D3执行中层当前步骤判断(公共).是否相等 等于 否 and D3执行中层导向步骤房间.进入步骤房间值 等于 牵头目标安排房间))  61194

ImplementMidReturnFirstStepComRespDto implementMidReturnFirstStepComRespDto = null;
    if(implementTopMidBasicGuideStepRoomRespDto !=null){
    ImplementMidReturnFirstStepComReqDto implementMidReturnFirstStepComReqDto=new ImplementMidReturnFirstStepComReqDto();
  implementMidReturnFirstStepComReqDto.setUseTypeCode("USE_MID_ISSUE_OBJTIVE");//CUSTOM_CONVENTION//sourceId:1091565_1_61195
  if(reqDto!=null){
      implementMidReturnFirstStepComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1052648_1_61195
implementMidReturnFirstStepComReqDto.setDeptTargetTaskBookId(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:1052644_1_61195
implementMidReturnFirstStepComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1052645_1_61195
implementMidReturnFirstStepComReqDto.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1052647_1_61195
implementMidReturnFirstStepComReqDto.setBatchCurrentStatus(reqDto.getBatchCurrentStatus());//SimpleFieldAssign//sourceId:1052650_1_61195
implementMidReturnFirstStepComReqDto.setOrgInductionRecordList(reqDto.getOrgInductionRecordList());//list-field-assign//sourceId:1550930_1_61195
implementMidReturnFirstStepComReqDto.setBackMsgSendType(reqDto.getBackMsgSendType());//SimpleFieldAssign//sourceId:1550931_1_61195
implementMidReturnFirstStepComReqDto.setMessageContent(reqDto.getMessageContent());//SimpleFieldAssign//sourceId:1550932_1_61195
           }
if(implementTopMidBasicGuideStepRoomRespDto!=null){
      implementMidReturnFirstStepComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:1052646_1_61195
    }

    /*D3执行中层返回第一步(公共)[3748]   */
    Assert.isNull(implementMidReturnFirstStepComReqDto.getDeptId(),"B3中层返回第二步(管理)-D3执行中层返回第一步(公共)-部门ID不能为空",false);
Assert.isNull(implementMidReturnFirstStepComReqDto.getDeptTargetTaskBookId(),"B3中层返回第二步(管理)-D3执行中层返回第一步(公共)-部门目标任务书ID不能为空",false);
Assert.isNull(implementMidReturnFirstStepComReqDto.getEvaluationTemplateId(),"B3中层返回第二步(管理)-D3执行中层返回第一步(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementMidReturnFirstStepComReqDto.getStepRoomValue(),"B3中层返回第二步(管理)-D3执行中层返回第一步(公共)-进入步骤房间值不能为空",false);
Assert.isNull(implementMidReturnFirstStepComReqDto.getBatchCode(),"B3中层返回第二步(管理)-D3执行中层返回第一步(公共)-批次标识不能为空",false);
Assert.isNull(implementMidReturnFirstStepComReqDto.getBatchCurrentStatus(),"B3中层返回第二步(管理)-D3执行中层返回第一步(公共)-批次现状不能为空",false);
Assert.isNull(implementMidReturnFirstStepComReqDto.getUseTypeCode(),"B3中层返回第二步(管理)-D3执行中层返回第一步(公共)-用途类型编码不能为空",false);
      implementMidReturnFirstStepComRespDto = fwAppOffStateClient.implementMidReturnFirstStepCom(implementMidReturnFirstStepComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto_3 = null;
    ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto_2=new ImplementConcBhvThemeLockComComReqDto();
  implementConcBhvThemeLockComComReqDto_2.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1540336_1_61196
implementConcBhvThemeLockComComReqDto_2.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540337_1_61196
implementConcBhvThemeLockComComReqDto_2.setWhetherUnlockBulk("FALSE");//sourceId:1540339_1_61196
if(reqDto!=null){
      implementConcBhvThemeLockComComReqDto_2.setCommPrimaryKey(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:1540338_1_61196
      }

    /*D2执行并发行为主题解锁(公共)[8388]   */
    Assert.isNull(implementConcBhvThemeLockComComReqDto_2.getPreventConcurrentLockingUnlocking(),"B3中层返回第二步(管理)-D2执行并发行为主题解锁(公共)-防并发上锁or解锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_2.getBehaviorThemeLockCode(),"B3中层返回第二步(管理)-D2执行并发行为主题解锁(公共)-行为主题锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_2.getCommPrimaryKey(),"B3中层返回第二步(管理)-D2执行并发行为主题解锁(公共)-通用主键ID不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_2.getWhetherUnlockBulk(),"B3中层返回第二步(管理)-D2执行并发行为主题解锁(公共)-是否批量解锁不能为空",false);
      implementConcBhvThemeLockComComRespDto_3 = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;



    }
else if((implementTopMidBasicCurrentBstepJudgeComRespDto!= null&&  implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() !=null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("TRUE"))){
       //elseif(D3执行中层当前步骤判断(公共).是否相等 等于 是)  61197

//异常结束 61198
      throw new BizException("B10100289","对不起！当前房间已变化，请刷新页面~",false);
    }
    }
else if((implementConcBhvThemeLockComComRespDto!= null&&  implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() !=null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("CONCURRENT_LOCK_FAILURE"))){
       //elseif(D2执行上并发中层步骤变更锁(公共).防并发上锁情况 等于 并发上锁失败)  61199

//异常结束 61200
      throw new BizException("B10100288","操作过于频繁，请稍后再试~",false);
    }
BffUpdateMidReturnSecondStepRespDto retData = new BffUpdateMidReturnSecondStepRespDto();
  if(implementTopMidBasicGuideStepRoomRespDto_1!=null){
      retData.setStepNameCode(implementTopMidBasicGuideStepRoomRespDto_1.getStepNameCode());//SimpleFieldAssign//sourceId:1540340_1
    }




return retData;
  }
/**
   * B3基层返回第一步(管理)[3060]
   * gen by moon at 2/24/2024, 1:08:57 PM
   */
    @Trace(operationName = "B3基层返回第一步(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffUpdateGrootsReturnFirstStepRespDto updateGrootsReturnFirstStep(BffUpdateGrootsReturnFirstStepReqDto reqDto){


ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto_1 =null;
//virtualUsage D2执行上并发基层步骤变更锁(公共)  61223
      ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto = null;
    ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto=new ImplementConcBhvThemeLockComComReqDto();
  implementConcBhvThemeLockComComReqDto.setPreventConcurrentLockingUnlocking("LOCK");//sourceId:1540444_1_61223
implementConcBhvThemeLockComComReqDto.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540445_1_61223
implementConcBhvThemeLockComComReqDto.setDuration(Long.valueOf(5));//CUSTOM_CONVENTION//sourceId:1540450_1_61223
implementConcBhvThemeLockComComReqDto.setTimeUnitType("MINUTES");//sourceId:1540451_1_61223
implementConcBhvThemeLockComComReqDto.setHandlingMethodConcurrentLockFailure("CONCURRENT_LOCK_FAILURE_NO_ERROR_REPORTED");//sourceId:1540452_1_61223
if(reqDto!=null){
      implementConcBhvThemeLockComComReqDto.setCommPrimaryKey(reqDto.getDeptOkrTargetId());//SimpleFieldAssign//sourceId:1540446_1_61223
    }

    /*D2执行上并发基层步骤变更锁(公共)[8388]   */
    Assert.isNull(implementConcBhvThemeLockComComReqDto.getPreventConcurrentLockingUnlocking(),"B3基层返回第一步(管理)-D2执行上并发基层步骤变更锁(公共)-防并发上锁or解锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getBehaviorThemeLockCode(),"B3基层返回第一步(管理)-D2执行上并发基层步骤变更锁(公共)-行为主题锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getCommPrimaryKey(),"B3基层返回第一步(管理)-D2执行上并发基层步骤变更锁(公共)-通用主键ID不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getDuration(),"B3基层返回第一步(管理)-D2执行上并发基层步骤变更锁(公共)-锁定时长不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getTimeUnitType(),"B3基层返回第一步(管理)-D2执行上并发基层步骤变更锁(公共)-时间单位类型不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getHandlingMethodConcurrentLockFailure(),"B3基层返回第一步(管理)-D2执行上并发基层步骤变更锁(公共)-并发上锁失败处理方式不能为空",false);
      implementConcBhvThemeLockComComRespDto = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((implementConcBhvThemeLockComComRespDto!= null&&  implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() !=null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("EMPTY_LOCK_SUCCESSFUL"))) {
        //if(D2执行上并发基层步骤变更锁(公共).防并发上锁情况 等于 空上锁成功)  47516

ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto = null;
    ImplementTopMidBasicGuideStepRoomReqDto implementTopMidBasicGuideStepRoomReqDto=new ImplementTopMidBasicGuideStepRoomReqDto();
  implementTopMidBasicGuideStepRoomReqDto.setRollbackExecuteTargetDiv("1");//CUSTOM_CONVENTION//sourceId:1203820_1_51062
implementTopMidBasicGuideStepRoomReqDto.setBatchOperateScene("BASIC");//sourceId:1203821_1_51062

    /*D3基层导向步骤房间[7600]   */
    Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getRollbackExecuteTargetDiv(),"B3基层返回第一步(管理)-D3基层导向步骤房间-返回执行目标安排不能为空",false);
Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getBatchOperateScene(),"B3基层返回第一步(管理)-D3基层导向步骤房间-高/中/基层操作场景不能为空",false);
      implementTopMidBasicGuideStepRoomRespDto = fwAppEvaSystemClient.implementTopMidBasicGuideStepRoom(implementTopMidBasicGuideStepRoomReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      implementTopMidBasicGuideStepRoomRespDto_1 = implementTopMidBasicGuideStepRoomRespDto;
ImplementTopMidBasicCurrentBstepJudgeComRespDto implementTopMidBasicCurrentBstepJudgeComRespDto = null;
    if(implementTopMidBasicGuideStepRoomRespDto !=null){
    ImplementTopMidBasicCurrentBstepJudgeComReqDto implementTopMidBasicCurrentBstepJudgeComReqDto=new ImplementTopMidBasicCurrentBstepJudgeComReqDto();
implementTopMidBasicCurrentBstepJudgeComReqDto.setBatchOperateScene("BASIC");//sourceId:1091585_1_47757
if(reqDto!=null){
      implementTopMidBasicCurrentBstepJudgeComReqDto.setEntityId(reqDto.getDeptOkrTargetId());//SimpleFieldAssign//sourceId:1091581_1_47757
implementTopMidBasicCurrentBstepJudgeComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1091582_1_47757
    }
if(implementTopMidBasicGuideStepRoomRespDto!=null){
      implementTopMidBasicCurrentBstepJudgeComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:1091584_1_47757
    }

    /*D3执行基层当前步骤判断(公共)[7303]   */
    Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getEntityId(),"B3基层返回第一步(管理)-D3执行基层当前步骤判断(公共)-步骤内容实例ID不能为空",false);
Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getStepRoomValue(),"B3基层返回第一步(管理)-D3执行基层当前步骤判断(公共)-进入步骤房间值不能为空",false);
Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getThemeContentId(),"B3基层返回第一步(管理)-D3执行基层当前步骤判断(公共)-主题内容ID不能为空",false);
Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getBatchOperateScene(),"B3基层返回第一步(管理)-D3执行基层当前步骤判断(公共)-高/中/基层操作场景不能为空",false);
      implementTopMidBasicCurrentBstepJudgeComRespDto = fwAppOffStateClient.implementTopMidBasicCurrentBstepJudgeCom(implementTopMidBasicCurrentBstepJudgeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((implementTopMidBasicCurrentBstepJudgeComRespDto!= null&&  implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() !=null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("FALSE"))) {
        //if(D3执行基层当前步骤判断(公共).是否相等 等于 否)  47758

     ImplementGrootsReturnFirstStepComRespDto implementGrootsReturnFirstStepComRespDto = null;
    if(implementTopMidBasicGuideStepRoomRespDto !=null){
    ImplementGrootsReturnFirstStepComReqDto implementGrootsReturnFirstStepComReqDto=new ImplementGrootsReturnFirstStepComReqDto();
implementGrootsReturnFirstStepComReqDto.setUseTypeCode("USE_BASIC_ISSUE_EXECUTE_OBJTIVE");//CUSTOM_CONVENTION//sourceId:1091588_1_47760
  if(reqDto!=null){
      implementGrootsReturnFirstStepComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:849500_1_47760
implementGrootsReturnFirstStepComReqDto.setDeptOkrTargetId(reqDto.getDeptOkrTargetId());//SimpleFieldAssign//sourceId:849501_1_47760
implementGrootsReturnFirstStepComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:849502_1_47760
implementGrootsReturnFirstStepComReqDto.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:849504_1_47760
implementGrootsReturnFirstStepComReqDto.setBatchCurrentStatus(reqDto.getBatchCurrentStatus());//SimpleFieldAssign//sourceId:856658_1_47760
implementGrootsReturnFirstStepComReqDto.setOrgInductionRecordList(reqDto.getOrgInductionRecordList());//list-field-assign//sourceId:1550881_1_47760
implementGrootsReturnFirstStepComReqDto.setBackMsgSendType(reqDto.getBackMsgSendType());//SimpleFieldAssign//sourceId:1550879_1_47760
implementGrootsReturnFirstStepComReqDto.setMessageContent(reqDto.getMessageContent());//SimpleFieldAssign//sourceId:1550880_1_47760
    }
if(implementTopMidBasicGuideStepRoomRespDto!=null){
      implementGrootsReturnFirstStepComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:849503_1_47760
    }

    /*D3执行基层返回第一步(公共)[6331]   */
    Assert.isNull(implementGrootsReturnFirstStepComReqDto.getDeptId(),"B3基层返回第一步(管理)-D3执行基层返回第一步(公共)-部门ID不能为空",false);
Assert.isNull(implementGrootsReturnFirstStepComReqDto.getDeptOkrTargetId(),"B3基层返回第一步(管理)-D3执行基层返回第一步(公共)-部门OKR目标ID不能为空",false);
Assert.isNull(implementGrootsReturnFirstStepComReqDto.getEvaluationTemplateId(),"B3基层返回第一步(管理)-D3执行基层返回第一步(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementGrootsReturnFirstStepComReqDto.getStepRoomValue(),"B3基层返回第一步(管理)-D3执行基层返回第一步(公共)-进入步骤房间值不能为空",false);
Assert.isNull(implementGrootsReturnFirstStepComReqDto.getBatchCode(),"B3基层返回第一步(管理)-D3执行基层返回第一步(公共)-批次标识不能为空",false);
Assert.isNull(implementGrootsReturnFirstStepComReqDto.getBatchCurrentStatus(),"B3基层返回第一步(管理)-D3执行基层返回第一步(公共)-批次现状不能为空",false);
Assert.isNull(implementGrootsReturnFirstStepComReqDto.getUseTypeCode(),"B3基层返回第一步(管理)-D3执行基层返回第一步(公共)-用途类型编码不能为空",false);
Assert.isNull(implementGrootsReturnFirstStepComReqDto.getBackMsgSendType(),"B3基层返回第一步(管理)-D3执行基层返回第一步(公共)-回退消息发送类型不能为空",false);
      implementGrootsReturnFirstStepComRespDto = fwAppOffStateClient.implementGrootsReturnFirstStepCom(implementGrootsReturnFirstStepComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto_2 = null;
    ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto_1=new ImplementConcBhvThemeLockComComReqDto();
  implementConcBhvThemeLockComComReqDto_1.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1540466_1_61224
implementConcBhvThemeLockComComReqDto_1.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540467_1_61224
implementConcBhvThemeLockComComReqDto_1.setWhetherUnlockBulk("FALSE");//sourceId:1540469_1_61224
if(reqDto!=null){
      implementConcBhvThemeLockComComReqDto_1.setCommPrimaryKey(reqDto.getDeptOkrTargetId());//SimpleFieldAssign//sourceId:1540468_1_61224
    }

    /*D2执行并发行为主题解锁(公共)[8388]   */
    Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getPreventConcurrentLockingUnlocking(),"B3基层返回第一步(管理)-D2执行并发行为主题解锁(公共)-防并发上锁or解锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getBehaviorThemeLockCode(),"B3基层返回第一步(管理)-D2执行并发行为主题解锁(公共)-行为主题锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getCommPrimaryKey(),"B3基层返回第一步(管理)-D2执行并发行为主题解锁(公共)-通用主键ID不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getWhetherUnlockBulk(),"B3基层返回第一步(管理)-D2执行并发行为主题解锁(公共)-是否批量解锁不能为空",false);
      implementConcBhvThemeLockComComRespDto_2 = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



      }
else if((implementTopMidBasicCurrentBstepJudgeComRespDto!= null&&  implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() !=null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("TRUE"))){
       //elseif(D3执行基层当前步骤判断(公共).是否相等 等于 是)  61225

//异常结束 61226
      throw new BizException("B10100289","对不起！当前房间已变化，请刷新页面~",false);
    }
      }
else if((implementConcBhvThemeLockComComRespDto!= null&&  implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() !=null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("CONCURRENT_LOCK_FAILURE"))){
       //elseif(D2执行上并发基层步骤变更锁(公共).防并发上锁情况 等于 并发上锁失败)  61227

//异常结束 61228
      throw new BizException("B10100288","操作过于频繁，请稍后再试~",false);
      }
BffUpdateGrootsReturnFirstStepRespDto retData = new BffUpdateGrootsReturnFirstStepRespDto();
  if(implementTopMidBasicGuideStepRoomRespDto_1!=null){
      retData.setStepNameCode(implementTopMidBasicGuideStepRoomRespDto_1.getStepNameCode());//SimpleFieldAssign//sourceId:1203822_1
    }




return retData;
  }
/**
   * B3执行中基层刷新父子状态(管理)[6578]
   * gen by moon at 7/13/2023, 4:47:48 PM
   */
    @Trace(operationName = "B3执行中基层刷新父子状态(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffImplementMidOrBasicRefreshParentSonStateRespDto implementMidOrBasicRefreshParentSonState(BffImplementMidOrBasicRefreshParentSonStateReqDto reqDto){


       ImplementExecuteProgressOperationJudgeComRespDto implementExecuteProgressOperationJudgeComRespDto_1 =null;
//virtualUsage D3执行进度运行判断(公共)  47527
      ImplementExecuteProgressOperationJudgeComRespDto implementExecuteProgressOperationJudgeComRespDto = null;
    ImplementExecuteProgressOperationJudgeComReqDto implementExecuteProgressOperationJudgeComReqDto=new ImplementExecuteProgressOperationJudgeComReqDto();
  implementExecuteProgressOperationJudgeComReqDto.setUseTypeCode("USE_BRUSH_PARENT_SUB_STATE");//CUSTOM_CONVENTION//sourceId:1086139_1_47527
if(reqDto!=null){
      implementExecuteProgressOperationJudgeComReqDto.setObjectId(reqDto.getBatchSetId());//SimpleFieldAssign//sourceId:1086138_1_47527
implementExecuteProgressOperationJudgeComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1086140_1_47527
    }

    /*D3执行进度运行判断(公共)[7243]   */
    Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getObjectId(),"B3执行中基层刷新父子状态(管理)-D3执行进度运行判断(公共)-归属对象内容ID不能为空",false);
Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getUseTypeCode(),"B3执行中基层刷新父子状态(管理)-D3执行进度运行判断(公共)-用途类型编码不能为空",false);
Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getThemeContentId(),"B3执行中基层刷新父子状态(管理)-D3执行进度运行判断(公共)-主题内容ID不能为空",false);
      implementExecuteProgressOperationJudgeComRespDto = fwAppExecuteProgressClient.implementExecuteProgressOperationJudgeCom(implementExecuteProgressOperationJudgeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      implementExecuteProgressOperationJudgeComRespDto_1 = implementExecuteProgressOperationJudgeComRespDto;
if((implementExecuteProgressOperationJudgeComRespDto!= null&& implementExecuteProgressOperationJudgeComRespDto.getCustomField() == null )) {
        //if(D3执行进度运行判断(公共).操作过于频繁，请稍后再试文案故事 值等于空 )  47528

     ImplementMidOrBasicRefreshParentSonStateRespDto implementMidOrBasicRefreshParentSonStateRespDto = null;
    ImplementMidOrBasicRefreshParentSonStateReqDto implementMidOrBasicRefreshParentSonStateReqDto=new ImplementMidOrBasicRefreshParentSonStateReqDto();
  implementMidOrBasicRefreshParentSonStateReqDto.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:921554_1_47529
implementMidOrBasicRefreshParentSonStateReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:921555_1_47529
if(reqDto!=null){
      implementMidOrBasicRefreshParentSonStateReqDto.setBatchSetId(reqDto.getBatchSetId());//SimpleFieldAssign//sourceId:929892_1_47529
implementMidOrBasicRefreshParentSonStateReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:921553_1_47529
implementMidOrBasicRefreshParentSonStateReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:921552_1_47529
    }

    /*D3执行中基层刷新父子状态[6570]   */
    Assert.isNull(implementMidOrBasicRefreshParentSonStateReqDto.getBatchSetId(),"B3执行中基层刷新父子状态(管理)-D3执行中基层刷新父子状态-批次设置对象ID不能为空",false);
Assert.isNull(implementMidOrBasicRefreshParentSonStateReqDto.getEvaObjEntityId(),"B3执行中基层刷新父子状态(管理)-D3执行中基层刷新父子状态-被评对象内容表主键ID不能为空",false);
Assert.isNull(implementMidOrBasicRefreshParentSonStateReqDto.getEvaObjTypeCode(),"B3执行中基层刷新父子状态(管理)-D3执行中基层刷新父子状态-被评对象类型编码不能为空",false);
Assert.isNull(implementMidOrBasicRefreshParentSonStateReqDto.getTargetId(),"B3执行中基层刷新父子状态(管理)-D3执行中基层刷新父子状态-冗余目标ID不能为空",false);
Assert.isNull(implementMidOrBasicRefreshParentSonStateReqDto.getEvaluationTemplateId(),"B3执行中基层刷新父子状态(管理)-D3执行中基层刷新父子状态-冗余评价模板ID不能为空",false);
      implementMidOrBasicRefreshParentSonStateRespDto = fwAppOffStateClient.implementMidOrBasicRefreshParentSonState(implementMidOrBasicRefreshParentSonStateReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



      }
BffImplementMidOrBasicRefreshParentSonStateRespDto retData = new BffImplementMidOrBasicRefreshParentSonStateRespDto();
  if(implementExecuteProgressOperationJudgeComRespDto_1!=null){
      retData.setCustomField(implementExecuteProgressOperationJudgeComRespDto_1.getCustomField());//SimpleFieldAssign//sourceId:1086142_1
    }




return retData;
  }
/**
   * B3执行刷新当前下级父子状态(管理)[6577]
   * gen by moon at 7/14/2023, 12:29:31 AM
   */
    @Trace(operationName = "B3执行刷新当前下级父子状态(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffImplementRefreshCurrentSubordinateParentSonStateRespDto implementRefreshCurrentSubordinateParentSonState(BffImplementRefreshCurrentSubordinateParentSonStateReqDto reqDto){


       ImplementExecuteProgressOperationJudgeComRespDto implementExecuteProgressOperationJudgeComRespDto_1 =null;
//virtualUsage D3执行进度运行判断(公共)  47563
      ImplementExecuteProgressOperationJudgeComRespDto implementExecuteProgressOperationJudgeComRespDto = null;
    ImplementExecuteProgressOperationJudgeComReqDto implementExecuteProgressOperationJudgeComReqDto=new ImplementExecuteProgressOperationJudgeComReqDto();
  implementExecuteProgressOperationJudgeComReqDto.setUseTypeCode("USE_BRUSH_PARENT_SUB_STATE");//CUSTOM_CONVENTION//sourceId:1086224_1_47563
if(reqDto!=null){
      implementExecuteProgressOperationJudgeComReqDto.setObjectId(reqDto.getParentTargetContId());//SimpleFieldAssign//sourceId:1086223_1_47563
implementExecuteProgressOperationJudgeComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1086225_1_47563
    }

    /*D3执行进度运行判断(公共)[7243]   */
    Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getObjectId(),"B3执行刷新当前下级父子状态(管理)-D3执行进度运行判断(公共)-归属对象内容ID不能为空",false);
Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getUseTypeCode(),"B3执行刷新当前下级父子状态(管理)-D3执行进度运行判断(公共)-用途类型编码不能为空",false);
Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getThemeContentId(),"B3执行刷新当前下级父子状态(管理)-D3执行进度运行判断(公共)-主题内容ID不能为空",false);
      implementExecuteProgressOperationJudgeComRespDto = fwAppExecuteProgressClient.implementExecuteProgressOperationJudgeCom(implementExecuteProgressOperationJudgeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      implementExecuteProgressOperationJudgeComRespDto_1 = implementExecuteProgressOperationJudgeComRespDto;
if((implementExecuteProgressOperationJudgeComRespDto!= null&& implementExecuteProgressOperationJudgeComRespDto.getCustomField() == null )) {
        //if(D3执行进度运行判断(公共).操作过于频繁，请稍后再试文案故事 值等于空 )  47564

     ImplementUpdateCurrentSubordinateParentSonStateRespDto implementUpdateCurrentSubordinateParentSonStateRespDto = null;
    ImplementUpdateCurrentSubordinateParentSonStateReqDto implementUpdateCurrentSubordinateParentSonStateReqDto=new ImplementUpdateCurrentSubordinateParentSonStateReqDto();
  implementUpdateCurrentSubordinateParentSonStateReqDto.setUseTypeCode("USE_BRUSH_PARENT_SUB_STATE");//CUSTOM_CONVENTION//sourceId:1078693_1_47565
  if(reqDto!=null){
      implementUpdateCurrentSubordinateParentSonStateReqDto.setParentTableTypeCode(reqDto.getParentTableTypeCode());//SimpleFieldAssign//sourceId:921966_1_47565
implementUpdateCurrentSubordinateParentSonStateReqDto.setParentTargetContId(reqDto.getParentTargetContId());//SimpleFieldAssign//sourceId:921967_1_47565
implementUpdateCurrentSubordinateParentSonStateReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:921968_1_47565
    }

    /*D3执行更新当前下级内容父子状态[6580]   */
    Assert.isNull(implementUpdateCurrentSubordinateParentSonStateReqDto.getParentTableTypeCode(),"B3执行刷新当前下级父子状态(管理)-D3执行更新当前下级内容父子状态-父级内容表类型编码不能为空",false);
Assert.isNull(implementUpdateCurrentSubordinateParentSonStateReqDto.getParentTargetContId(),"B3执行刷新当前下级父子状态(管理)-D3执行更新当前下级内容父子状态-父级内容表主键ID不能为空",false);
Assert.isNull(implementUpdateCurrentSubordinateParentSonStateReqDto.getEvaluationTemplateId(),"B3执行刷新当前下级父子状态(管理)-D3执行更新当前下级内容父子状态-冗余评价模板ID不能为空",false);
Assert.isNull(implementUpdateCurrentSubordinateParentSonStateReqDto.getUseTypeCode(),"B3执行刷新当前下级父子状态(管理)-D3执行更新当前下级内容父子状态-用途类型编码不能为空",false);
      implementUpdateCurrentSubordinateParentSonStateRespDto = fwAppTargetContentClient.implementUpdateCurrentSubordinateParentSonState(implementUpdateCurrentSubordinateParentSonStateReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



      }
BffImplementRefreshCurrentSubordinateParentSonStateRespDto retData = new BffImplementRefreshCurrentSubordinateParentSonStateRespDto();
  if(implementExecuteProgressOperationJudgeComRespDto_1!=null){
      retData.setCustomField(implementExecuteProgressOperationJudgeComRespDto_1.getCustomField());//SimpleFieldAssign//sourceId:1086227_1
    }




return retData;
  }
/**
   * B3执行高层刷新父子状态(管理)[6579]
   * gen by moon at 7/13/2023, 4:47:52 PM
   */
    @Trace(operationName = "B3执行高层刷新父子状态(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffImplementTopRefreshParentSonStateRespDto implementTopRefreshParentSonState(BffImplementTopRefreshParentSonStateReqDto reqDto){


       ImplementExecuteProgressOperationJudgeComRespDto implementExecuteProgressOperationJudgeComRespDto_1 =null;
//virtualUsage D3执行进度运行判断(公共)  47524
      ImplementExecuteProgressOperationJudgeComRespDto implementExecuteProgressOperationJudgeComRespDto = null;
    ImplementExecuteProgressOperationJudgeComReqDto implementExecuteProgressOperationJudgeComReqDto=new ImplementExecuteProgressOperationJudgeComReqDto();
  implementExecuteProgressOperationJudgeComReqDto.setUseTypeCode("USE_BRUSH_PARENT_SUB_STATE");//CUSTOM_CONVENTION//sourceId:1086134_1_47524
if(reqDto!=null){
      implementExecuteProgressOperationJudgeComReqDto.setObjectId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1086133_1_47524
implementExecuteProgressOperationJudgeComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1086135_1_47524
    }

    /*D3执行进度运行判断(公共)[7243]   */
    Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getObjectId(),"B3执行高层刷新父子状态(管理)-D3执行进度运行判断(公共)-归属对象内容ID不能为空",false);
Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getUseTypeCode(),"B3执行高层刷新父子状态(管理)-D3执行进度运行判断(公共)-用途类型编码不能为空",false);
Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getThemeContentId(),"B3执行高层刷新父子状态(管理)-D3执行进度运行判断(公共)-主题内容ID不能为空",false);
      implementExecuteProgressOperationJudgeComRespDto = fwAppExecuteProgressClient.implementExecuteProgressOperationJudgeCom(implementExecuteProgressOperationJudgeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      implementExecuteProgressOperationJudgeComRespDto_1 = implementExecuteProgressOperationJudgeComRespDto;
if((implementExecuteProgressOperationJudgeComRespDto!= null&& implementExecuteProgressOperationJudgeComRespDto.getCustomField() == null )) {
        //if(D3执行进度运行判断(公共).操作过于频繁，请稍后再试文案故事 值等于空 )  47525

     ImplementTopRefreshParentSonStateRespDto implementTopRefreshParentSonStateRespDto = null;
    ImplementTopRefreshParentSonStateReqDto implementTopRefreshParentSonStateReqDto=new ImplementTopRefreshParentSonStateReqDto();
  implementTopRefreshParentSonStateReqDto.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:921560_1_47526
implementTopRefreshParentSonStateReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:921561_1_47526
if(reqDto!=null){
      implementTopRefreshParentSonStateReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:921562_1_47526
    }

    /*D3执行高层刷新父子状态[6574]   */
    Assert.isNull(implementTopRefreshParentSonStateReqDto.getEvaObjEntityId(),"B3执行高层刷新父子状态(管理)-D3执行高层刷新父子状态-被评对象内容表主键ID不能为空",false);
Assert.isNull(implementTopRefreshParentSonStateReqDto.getEvaObjTypeCode(),"B3执行高层刷新父子状态(管理)-D3执行高层刷新父子状态-被评对象类型编码不能为空",false);
Assert.isNull(implementTopRefreshParentSonStateReqDto.getEvaluationTemplateId(),"B3执行高层刷新父子状态(管理)-D3执行高层刷新父子状态-冗余评价模板ID不能为空",false);
      implementTopRefreshParentSonStateRespDto = fwAppOffStateClient.implementTopRefreshParentSonState(implementTopRefreshParentSonStateReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



      }
BffImplementTopRefreshParentSonStateRespDto retData = new BffImplementTopRefreshParentSonStateRespDto();
  if(implementExecuteProgressOperationJudgeComRespDto_1!=null){
      retData.setCustomField(implementExecuteProgressOperationJudgeComRespDto_1.getCustomField());//SimpleFieldAssign//sourceId:1086137_1
    }




return retData;
  }



}
